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

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

2017-11-03T18:30:25Z

Екатерина: Новая страница: «В самом начале добавьте название алгоритма и фамилию автора статьи.»

В самом начале добавьте название алгоритма и фамилию автора статьи.

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

2017-11-03T18:27:59Z

Екатерина:

В начале перед содержанием добавьте название алгоритма и фамилию автора статьи.

В разделе 1.2 там где вы пишите max (от функции)- максимум берется по всем стратегиям x из X и т.п. Добавьте.

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

2017-11-03T18:27:11Z

Екатерина:

В начале перед содержанием добавьте название алгоритма и фамилию автора статьи.

В разделе 1.2 там где вы пишите max (от функции)- максимум берется по чему?

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

2017-11-03T18:25:26Z

Екатерина: Новая страница: «В начале перед содержанием добавьте название алгоритма и фамилию автора статьи.»

В начале перед содержанием добавьте название алгоритма и фамилию автора статьи.

Обсуждение участника:Chist/Метод Ньютона

2017-11-03T17:51:35Z

Екатерина: Новая страница: «Поправить предложение: "При нас интересуют не только действительные корни, но и комплек…»

Поправить предложение: "При нас интересуют не только действительные корни, но и комплексные, будет производить перебор по некоторой сетке на комплексной плоскости."

В самом начале перед содержанием добавить название алгоритма и фамилию автора статьи.

Обсуждение участника:Valkyrie/Адаптивное интегрирование

2017-11-03T17:34:52Z

Екатерина:

"к характеру изменения функции -вводил разные значения шага " - поправьте тире.

Обсуждение участника:Valkyrie/Адаптивное интегрирование

2017-11-03T17:34:36Z

Екатерина: Новая страница: « "к характеру изменения функции -вводил разные значения шага " -- поправьте тире.»

"к характеру изменения функции -вводил разные значения шага " -- поправьте тире.

Обсуждение участника:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-11-03T14:08:55Z

Екатерина: Новая страница: «В начале перед содержанием добавьте название алгоритма и фамилию автора статьи»

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T08:09:49Z

Екатерина:

{{Assignment}}
Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
В алгоритме есть три параллельные области:
*построение матрицы связей;
*построение локальных куч;
*for-цикл, реализующий обновление всех куч при слиянии двух кластеров.
С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

Программа тестировалась на IBM pSeries 690 HPC Regatta. Ниже в таблице представлены результаты работы программы на 1, 2, 4, 8, 16 потоках:
{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

[[File:graphi.jpg]]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T08:07:57Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
В алгоритме есть три параллельные области:
*построение матрицы связей;
*построение локальных куч;
*for-цикл, реализующий обновление всех куч при слиянии двух кластеров.
С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

Программа тестировалась на IBM pSeries 690 HPC Regatta. Ниже в таблице представлены результаты работы программы на 1, 2, 4, 8, 16 потоках:
{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

[[File:graphi.jpg]]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T08:05:33Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
В алгоритме есть три параллельные области:
*построение матрицы связей;
*построение локальных куч;
*for-цикл, реализующий обновление всех куч при слиянии двух кластеров.
С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

Программа тестировалась на IBM pSeries 690 HPC Regatta. Ниже в таблице представлены результаты работы программы на 1, 2, 4, 8, 16 потоках:
{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T08:01:29Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
В алгоритме есть три параллельные области:
*построение матрицы связей;
*построение локальных куч;
*for-цикл, реализующий обновление всех куч при слиянии двух кластеров.

{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T08:00:52Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

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

{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T07:52:06Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

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

{| class="wikitable"
|-
!данные/потоки||1||2||4||8||16
|-
|128||0.84||0.54||0.46||0.38||0.30
|-
|256||7.10||3.77||2.07||1.87||0.95
|-
|512||67.09||34.66||17.35||10.50||5.54
|-
|1024||610.29||310.55||157.86||83.59||45.18
|}

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-20T07:46:55Z

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

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

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

{| class="wikitable"
|-
!Заголовок 1||Заголовок 2
|-
|Ячейка 1*1||Ячейка 2*1
|-
|Ячейка 1*2||Ячейка 2*2
|-
|Ячейка 1*3||Ячейка 2*3
|}

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-15T22:48:02Z

Екатерина: /* Информационный граф */

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
[[File:5.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-15T22:09:56Z

Екатерина: /* Информационный граф */

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:4.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-15T22:05:54Z

Екатерина: /* Информационный граф */

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:3.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-11-15T22:01:31Z

Екатерина: /* Информационный граф */

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:1.jpg]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T20:54:32Z

Екатерина:

{{Assignment}}
Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:20:19Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 2.7), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:19:45Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8), Жайлауова Шынар (1.2, 1.7, 1.9, 1.10, 2.7)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:18:59Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 1.10), Жайлауова Шынар (1.2, 1.7, 1.8, 1.9, 2.7)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:17:18Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.8, 1.10) , Жайлауова Шынар (1.2, 1.7, 1.8, 1.9, 2.7)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:16:38Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, 1.6, 1.10) , Жайлауова Шынар (1.2, 1.7, 1.8, 1.9, 2.7)
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:15:41Z

Екатерина:

Авторы: Таратута Екатерина (1.1, 1.3, 1.4, 1.5, , Жайлауова Шынар (1.2
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:13:14Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, в котором значением i-го объекта является номер кластера, к которому он был приписан.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T18:06:50Z

Екатерина: /* Макроструктура алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

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

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, значениями которого являются номера кластера, к которому он был отнесен.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T17:58:43Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' массив объектов, значениями которого являются номера кластера, к которому он был отнесен.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T17:41:11Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' !!!!
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T17:40:01Z

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

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' !!!!
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA<ref>https://github.com/cran/cba/blob/master/R/rock.r</ref> в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T17:37:48Z

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

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' !!!!
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka<ref>https://sourceforge.net/projects/feed4weka/files/</ref> - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:57:04Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' !!!!
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:43:56Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:24:56Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>b[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. Ожидаемый объем: <math>O(min\{nm_mm_a, n^2\})</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:19:03Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

:'''Процедура кластеризации:'''
:*'''Входные данные:''' на вход подается симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:17:11Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>, где <math>m_m</math> - максимальное число соседей произвольного объекта, <math>m_a</math> - среднее значение числа соседей произвольного объекта.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:13:40Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>. В общем случае не у каждой пары точек будут связи. Поэтому ожидаемый объем данных может быть намного меньше, а именно <math>O(min\{nm_mm_a, n^2\})</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:09:23Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:08:38Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>. Элемент <math>a[i,j]:</math> указывает на количество
связей между соответствующими объектами.
:*'''Объем данных:''' <math>\frac{n(n-1)}{2}</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:04:55Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0</math>.
:*'''Объем данных:''' <math>n*r</math>.
:*'''Выходные данные:''' симметричная матрица связей <math>B</math> размера <math>n\times n</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:03:12Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0:</math>.
:*'''Объем данных:''' <math>n*r</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:02:22Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Процедура <math>compute\_links()</math>:'''
:*'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:01:04Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:'''.
:*'''Процедура <math>compute\_links()</math>:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T16:00:11Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:'''.
:*'''Процедура <math>compute\_links()</math>:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе - <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T15:57:50Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:'''.
:*'''Процедура <math>compute_links()</math>:'''на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе - <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T15:57:33Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:'''.
*:'''Процедура <math>compute_links()</math>:'''на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе - <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T15:55:52Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i</math>-ый объект обладает <math>j</math>-ым атрибутом, иначе - <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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

Метод Холецкого (квадратного корня), точечный вещественный вариант

2016-10-31T15:55:12Z

Екатерина: /* Описание входных и выходных данных */

== Описание свойств и структуры алгоритма ==

=== Словесное описание алгоритма ===

'''Метод Холецкого''' (в советской математической литературе называется также '''методом квадратного корня''') используется для разложения положительно определённых эрмитовых (''в вещественном случае - симметрических'') матриц в виде <math>A = L L^*</math> (<math>L</math> — левая треугольная матрица) или в виде <math>A = U^* U</math> (<math>U</math> — правая треугольная матрица; эти разложения совершенно эквивалентны друг другу по вычислениям и различаются только способом представления данных). Он заключается в реализации формул для элементов матрицы <math>L</math>, получающихся из вышеприведённого равенства единственным образом. Получил распространение благодаря следующим особенностям: а) симметричность матрицы позволяет хранить и вычислять только чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций в сравнении с, например, разложением по методу Гаусса; б) позволяет использовать так называемый ''режим накопления'', обусловленный тем, что значительную часть вычислений составляют ''вычисления скалярных произведений''; с его использованием разложение методом Холецкого имеет наименьшее ''эквивалентное возмущение'' из всех известных разложений матриц.

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

Исходные данные: положительно определённая симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: левая треугольная матрица <math>L</math> (элементы <math>l_{ij}</math>).

Формулы метода:
:<math>
\begin{align}
l_{11} & = \sqrt{a_{11}}, \\
l_{j1} & = \frac{a_{j1}}{l_{11}}, \quad j \in [2, n], \\
l_{ii} & = \sqrt{a_{ii} - \sum_{p = 1}^{i - 1} l_{ip}^2}, \quad i \in [2, n], \\
l_{ji} & = \left (a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp} \right ) / l_{ii}, \quad i \in [2, n - 1], j \in [i + 1, n].
\end{align}
</math>

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

В ряде реализаций деление на диагональный элемент выполняется в два этапа: вычисление <math>\frac{1}{l_{ii}}</math> и затем умножение на него всех (видоизменённых) <math>a_{ji}</math> . Здесь мы этот вариант алгоритма не рассматриваем. Заметим только, что он имеет худшие параллельные характеристики, чем представленный.

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

Вычислительное ядро последовательной версии метода Холецкого можно составить из множественных (всего их <math>\frac{n (n - 1)}{2}</math>) вычислений скалярных произведений строк матрицы:

:<math>\sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math>

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

:<math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math><nowiki/>

в которых и встречаются скалярные произведения, ведутся не в порядке «вычислили скалярное произведение, а потом вычли его из элемента», а путём вычитания из элемента покомпонентных произведений, являющихся частями скалярных произведений. Поэтому следует считать вычислительным ядром метода не вычисления скалярных произведений, а вычисления выражений

:<math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math>

в ''режиме накопления'' или без него.

Тем не менее, в популярных зарубежных реализациях точечного метода Холецкого, в частности, в библиотеках LINPACK и LAPACK, основанных на BLAS, используются именно вычисления скалярных произведений в виде вызова соответствующих подпрограмм BLAS (конкретно — функции SDOT). На последовательном уровне это влечёт за собой дополнительную операцию суммирования на каждый из <math>\frac{n (n + 1)}{2}</math> вычисляемый элемент матрицы <math>L</math> и некоторое замедление работы программы (о других следствиях рассказано ниже в разделе «[[#Существующие реализации алгоритма|Существующие реализации алгоритма]]»). Поэтому в данных вариантах ядром метода Холецкого будут вычисления этих скалярных произведений.

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

Как уже записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>\frac{n (n - 1)}{2}</math>) вычисления сумм

:<math>a_{ji}-\sum_{p=1}^{i-1}l_{ip} l_{jp}</math>

в режиме накопления или без него.

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

Чтобы понять последовательность исполнения, перепишем формулы метода так:

1. <math>l_{11}= \sqrt{a_{11}}</math>

2. <math>l_{j1}= \frac{a_{j1}}{l_{11}}</math> (при <math>j</math> от <math>2</math> до <math>n</math>).

Далее для всех <math>i</math> от <math>2</math> до <math>n</math> по нарастанию выполняются

3. <math>l_{ii} = \sqrt{a_{ii} - \sum_{p = 1}^{i - 1} l_{ip}^2}</math> и

4. (кроме <math>i = n</math>): <nowiki/><math>l_{ji} = \left (a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp} \right ) / l_{ii}</math> (для всех <math>j</math> от <math>i + 1</math> до <math>n</math>).

После этого (если <math>i < n</math>) происходит переход к шагу 3 с бо́льшим <math>i</math>.

Особо отметим, что вычисления сумм вида <math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math> в обеих формулах производят в режиме накопления вычитанием из <math>a_{ji}</math> произведений <math>l_{ip} l_{jp}</math> для <math>p</math> от <math>1</math> до <math>i - 1</math>, c нарастанием <math>p</math>. Другие порядки выполнения суммирования не распространены.

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

Для разложения матрицы порядка n методом Холецкого в последовательном (наиболее быстром) варианте требуется:

* <math>n</math> вычислений квадратного корня,
* <math>\frac{n(n-1)}{2}</math> делений,
* по <math>\frac{n^3-n}{6}</math> умножений и сложений (вычитаний) — ''основная часть алгоритма''.

При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности (или использования функции вроде DPROD в Фортране), что ещё больше увеличивает долю умножений и сложений/вычитаний во времени, требуемом для выполнения метода Холецкого.

При классификации по последовательной сложности, таким образом, метод Холецкого относится к алгоритмам ''с кубической сложностью''.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]] как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин, расположенных в целочисленных узлах трёх областей разной размерности.

'''Первая''' группа вершин расположена в одномерной области, соответствующая ей операция вычисляет функцию SQRT.
Естественно введённая единственная координата каждой из вершин <math>i</math> меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения.

Аргумент этой функции

* при <math>i = 1</math> — элемент ''входных данных'', а именно <math>a_{11}</math>;
* при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1</math>, <math>i</math>, <math>i - 1</math>.
Результат срабатывания операции является ''выходным данным'' <math>l_{ii}</math>.

'''Вторая''' группа вершин расположена в одномерной области, соответствующая ей операция <math>a / b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>l_{ji}</math>.

'''Третья''' группа вершин расположена в трёхмерной области, соответствующая ей операция <math>a - b * c</math>.
Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>2</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i</math> до <math>n</math>, принимая все целочисленные значения;
* <math>p</math> — меняется в диапазоне от <math>1</math> до <math>i - 1</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>p = 1</math> элемент входных данных <math>a_{ji}</math>;
** при <math>p > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i, j, p - 1</math>;
*<math>b</math> — результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>p, i</math>;
*<math>c</math> — результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>p, j</math>;

Результат срабатывания операции является ''промежуточным данным'' алгоритма.

Описанный граф можно посмотреть на рисунке, выполненном для случая <math>n = 4</math>. Здесь вершины первой группы обозначены жёлтым цветом и буквосочетанием sq, вершины второй — зелёным цветом и знаком деления, третьей — красным цветом и буквой f. Вершины, соответствующие операциям, производящим выходные данные алгоритма, выполнены более крупно. Дублирующие друг друга дуги даны как одна. На первом изображении показан граф алгоритма согласно классическому определению , на втором к графу алгоритма добавлены вершины , соответствующие входным данным ( обозначены синим цветом ) и выходным данным ( обозначены розовым цветом ).

[[file:Cholesky full.png|thumb|center|1400px]]
[[file:Cholesky full_in_out.png|thumb|center|1400px]]

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

Для разложения матрицы порядка <math>n</math> методом Холецкого в параллельном варианте требуется последовательно выполнить следующие ярусы:
* <math>n</math> ярусов с вычислением квадратного корня (единичные вычисления в каждом из ярусов),
* <math>n - 1</math> ярус делений (в каждом из ярусов линейное количество делений, в зависимости от яруса — от <math>1</math> до <math>n - 1</math>),
* по <math>n - 1</math> ярусов умножений и сложений/вычитаний (в каждом из ярусов — квадратичное количество операций, от <math>1</math> до <math>\frac{n^2 - n}{2}</math>.

Таким образом, в параллельном варианте, в отличие от последовательного, вычисления квадратных корней и делений будут определять довольно значительную долю требуемого времени. При реализации на конкретных архитектурах наличие в отдельных ярусах [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] отдельных вычислений квадратных корней может породить и другие проблемы. Например, при реализации на ПЛИСах остальные вычисления (деления и тем более умножения и сложения/вычитания) могут быть конвейеризованы, что даёт экономию и по ресурсам на программируемых платах; вычисления же квадратных корней из-за их изолированности приведут к занятию ресурсов на платах, которые будут простаивать большую часть времени. Таким образом, общая экономия в 2 раза, из-за которой метод Холецкого предпочитают в случае симметричных задач тому же методу Гаусса, в параллельном случае уже имеет место вовсе не по всем ресурсам, и главное - не по требуемому времени.

При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности, а в параллельном варианте это означает, что практически все промежуточные вычисления для выполнения метода Холецкого в режиме накопления должны быть двойной точности. В отличие от последовательного варианта это означает увеличение требуемой памяти почти в 2 раза.

При классификации по высоте ЯПФ, таким образом, метод Холецкого относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность будет ''квадратичной''.

=== Описание входных и выходных данных ===

'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.
* <math>A</math> – положительно определённая матрица, т. е. для любых ненулевых векторов <math>\vec{x}</math> выполняется <math>\vec{x}^T A \vec{x} > 0</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом. Например, в библиотеке, реализованной в НИВЦ МГУ, матрица A хранилась в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части.

'''Выходные данные''': левая треугольная матрица <math>L</math> (элементы <math>l_{ij}</math>).

'''Объём выходных данных'''.
*Процедура <math>\frac{n (n + 1)}{2}</math> (в силу треугольности достаточно хранить только ненулевые - диагональ и поддиагональные - элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом. Например, в той же библиотеке, созданной в НИВЦ МГУ, матрица <math>L</math> хранилась в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части.

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

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''квадратичным'' (отношение кубической к линейной).

При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – всего лишь ''линейна''.

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

Дуги информационного графа, исходящие из вершин, соответствующих операциям квадратного корня и деления, образуют пучки т. н. рассылок линейной мощности (то есть степень исхода этих вершин и мощность работы с этими данными — линейная функция от порядка матрицы и координат этих вершин). При этом естественно наличие в этих пучках «длинных» дуг. Остальные дуги локальны.

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

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

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

В простейшем (без перестановок суммирования) варианте метод Холецкого на Фортране можно записать так:
<source lang="fortran">
DO I = 1, N
S = A(I,I)
DO IP=1, I-1
S = S - DPROD(A(I,P), A(I,IP))
END DO
A(I,I) = SQRT (S)
DO J = I+1, N
S = A(J,I)
DO IP=1, I-1
S = S - DPROD(A(I,P), A(J,IP))
END DO
A(J,I) = S/A(I,I)
END DO
END DO
</source>
При этом для реализации режима накопления переменная <math>S</math> должна быть двойной точности.

Для метода Холецкого существует блочная версия, которая отличается от точечной не тем, что операции над числами заменены на аналоги этих операций над блоками; её построение основано на том, что практически все циклы точечной версии имеют тип SchedDo в терминах методологии, основанной на исследовании информационного графа и, следовательно, могут быть расщеплены на составляющие. Тем не менее, обычно блочную версию метода Холецкого записывают не в виде программы с расщеплёнными и переставленными циклами, а в виде программы, подобной реализации точечного метода, в которой вместо соответствующих скалярных операций присутствуют операции над блоками.

Для обеспечения локальности работы с памятью представляется более эффективной такая схема метода Холецкого (полностью эквивалентная описанной), когда исходная матрица и её разложение хранятся не в нижнем-левом, а в правом-верхнем треугольнике. Это связано с особенностью размещения массивов в Фортране и тем, что в этом случае вычисления скалярных произведений будут идти с выборкой идущих подряд элементов массива.

Есть и другой вариант точечной схемы: использовать вычисляемые элементы матрицы <math>L</math> в качестве аргументов непосредственно «сразу после» их вычисления. Такая программа будет выглядеть так:
<source lang="fortran">
DO I = 1, N
A(I,I) = SQRT (A(I, I))
DO J = I+1, N
A(J,I) = A(J,I)/A(I,I)
END DO
DO K=I+1,N
DO J = K, N
A(J,K) = A(J,K) - A(J,I)*A(K,I)
END DO
END DO
END DO
</source>
Как видно, в этом варианте для реализации режима накопления одинарной точности мы должны будем объявить двойную точность для массива, хранящего исходные данные и результат. Подчеркнём, что [[глоссарий#Граф алгоритма|граф алгоритма]] обеих схем - один и тот же (из п.1.7), если не считать изменением замену умножения на функцию DPROD!

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

==== Описание локальности алгоритма ====

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

===== Описание структуры обращений в память и качественная оценка локальности =====

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рисунок 1. Реализация метода Холецкого. Общий профиль обращений в память]]

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

Видно, что на каждой <math>i</math>-й итерации используются все адреса, кроме первых <math>k_i</math>, при этом с ростом <math>i</math> увеличивается значение <math>k_i</math>. Также можно заметить, что число обращений в память на каждой итерации растет примерно до середины работы программы, после чего уменьшается вплоть до завершения работы. Это позволяет говорить о том, что данные в программе используются неравномерно, при этом многие итерации, особенно в начале выполнения программы, задействуют большой объем данных, что приводит к ухудшению локальности.

Однако в данном случае основным фактором, влияющим на локальность работы с памятью, является строение итерации. Рассмотрим фрагмент профиля, соответствующий нескольким первым итерациям.

[[file:Cholesky_locality2.jpg|thumb|center|700px|Рисунок 2. Реализация метода Холецкого. Фрагмент профиля (несколько первых итераций)]]

Исходя из рисунка 2 видно, что каждая итерация состоит из двух различных фрагментов. Фрагмент 1 – последовательный перебор (с некоторым шагом) всех адресов, начиная с некоторого начального. При этом к каждому элементу происходит мало обращений. Такой фрагмент обладает достаточно неплохой пространственной локальностью, так как шаг по памяти между соседними обращениями невелик, но плохой временно́й локальностью, поскольку данные редко используются повторно.

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

После рассмотрения фрагмента профиля на рис. 2 можно оценить общую локальность двух фрагментов на каждой итерации. Однако стоит рассмотреть более подробно, как устроен каждый из фрагментов.

[[file:Cholesky_locality3.jpg|thumb|center|700px|Рисунок 3. Реализация метода Холецкого. Фрагмент профиля (часть одной итерации)]]

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

Стоит отметить, что выводы на основе рис. 3 просто дополняют общее представлении о строении профиля обращений; сделанные на основе рис. 2 выводы относительно общей локальности двух фрагментов остаются верны.

===== Количественная оценка локальности =====

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

[[file:Cholesky_locality4.jpg|thumb|center|700px|Рисунок 4. Сравнение значений оценки daps]]

На рисунке 4 значения приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что реализация метода Холецкого характеризуется достаточно высокой скоростью взаимодействия с памятью, однако ниже, чем, например, у теста Линпак или реализации метода Якоби.

Вторая характеристика – cvg – предназначена для получения более машинно-независимой оценки локальности. Она определяет, насколько часто в программе необходимо подтягивать данные в кэш-память. Соответственно, чем меньше значение cvg, тем реже это нужно делать, тем лучше локальность.

[[file:Cholesky_locality5.jpg|thumb|center|700px|Рисунок 5. Сравнение значений оценки cvg]]

На рисунке 5 значения приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, согласно данной оценке, реализация метода Холецкого оказалась ниже в списке по сравнению с оценкой daps.



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

Как нетрудно видеть по структуре графа алгоритма, вариантов распараллеливания алгоритма довольно много. Например, во втором варианте (см. раздел «[[#Особенности реализации последовательного алгоритма|Особенности реализации последовательного алгоритма]]») все внутренние циклы параллельны, в первом — параллелен цикл по <math>J</math>. Тем не менее, простое распараллеливание таким способом «в лоб» вызовет такое количество пересылок между процессорами с каждым шагом по внешнему циклу, которое почти сопоставимо с количеством арифметических операций. Поэтому перед размещением операций и данных между процессорами вычислительной системы предпочтительно разбиение всего пространства вычислений на блоки, с сопутствующим разбиением обрабатываемого массива.

Многое зависит от конкретного типа вычислительной системы. Присутствие конвейеров на узлах многопроцессорной системы делает рентабельным параллельное вычисление нескольких скалярных произведений сразу. Подобная возможность есть и на программировании ПЛИСов, но там быстродействие будет ограничено медленным последовательным выполнением операции извлечения квадратного корня.

В принципе, возможно и использование т. н. «скошенного» параллелизма. Однако его на практике никто не использует, из-за усложнения управляющей структуры программы.

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

==== Описание масштабируемости алгоритма ====

==== Описание масштабируемости реализации алгоритма ====

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

Для существующих параллельных реализаций характерно отнесение всего ресурса параллелизма на блочный уровень. Относительно низкая эффективность работы связана с проблемами внутри одного узла, следующим фактором является неоптимальное соотношение между «арифметикой» и обменами. Видно, что при некотором (довольно большом) оптимальном размере блока обмены влияют не так уж сильно.

Для проведения экспериментов использовалась реализация разложения Холецкого, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdpotrf). Все результаты получены на суперкомпьютере «Ломоносов». Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор Intel с опцией –O2.

[[file:Cholesky_efficiency1.jpg|thumb|center|700px]]

На рисунке показана эффективность реализации разложения Холецкого (случай использования нижних треугольников матриц) для разного числа процессов и разной размерности матрицы (10000, 20000 и 50000 элементов). Видно, что общая эффективность достаточно невысока – даже при малом числе процессов менее 10 %. Однако при всех размерностях матрицы эффективность снижается очень медленно – в самом худшем случае, при N = 10000, при увеличении числа процессов с 16 до 900 (в 56 раз) эффективность падает с 7 % до 0,8 % (всего в 9 раз). При N = 50000 эффективность уменьшается еще медленнее.

Также стоит отметить небольшое суперлинейное ускорение, полученное на 4-х процессах для N = 10000 и N = 20000 (для N = 50000 провести эксперименты на таком малом числе процессов не удалось). Помимо более эффективной работы с кэш-памятью, оно, видимо, обусловлено тем, что эти 4 процесса помещаются на ядрах одного процессора, что позволяет использовать общую память, и, соответственно, не приводит к появлению накладных расходов, связанных с пересылкой данных.

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

Как видно по показателям SCALAPACK на суперкомпьютерах, обмены при большом n хоть и уменьшают эффективность расчётов, но слабее, чем неоптимальность организации расчётов внутри одного узла. Поэтому, видимо, следует сначала оптимизировать не блочный алгоритм, а подпрограммы, используемые на отдельных процессорах: точечный метод Холецкого, перемножения матриц и др. подпрограммы. [[#Существующие реализации алгоритма|Ниже]] содержится информация о возможном направлении такой оптимизации.

В отношении же архитектуры типа ПЛИС вполне показателен тот момент, что разработчики — наполнители библиотек для ПЛИСов пока что не докладывают об успешных и эффективных реализациях точечного метода Холецкого на ПЛИСах. Это связано со следующим свойством информационной структуры алгоритма: если операции деления или вычисления выражений <math>a - bc</math> являются не только массовыми, но и параллельными, и потому их вычисления сравнительно легко выстраивать в конвейеры, то операции извлечения квадратных корней являются узким местом алгоритма - отведённое на эту операцию оборудование неизбежно будет простаивать большую часть времени. Поэтому для эффективной реализации на ПЛИСах алгоритмов, столь же хороших по вычислительным характеристикам, как и метод квадратного корня, следует использовать не метод Холецкого, а его давно известную модификацию без извлечения квадратных корней — разложение матрицы в произведение <math>L D L^T</math>.

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

Точечный метод Холецкого реализован как в основных библиотеках программ отечественных организаций, так и в западных пакетах LINPACK, LAPACK, SCALAPACK и др.

При этом в отечественных реализациях, как правило, выполнены стандартные требования к методу с точки зрения ошибок округления, то есть, реализован режим накопления, и обычно нет лишних операций. Правда, анахронизмом в наше время выглядит то, что ряд старых отечественных реализаций использует для экономии памяти упаковку матриц <math>A</math> и <math>L</math> в одномерный массив. При реальных вычислениях на современных вычислительных системах данная упаковка только создаёт дополнительные накладные расходы. Однако отечественные реализации, не использующие такую упаковку, вполне отвечают требованиям современности в отношении вычислительной точности метода.

Реализация точечного метода Холецкого в современных западных пакетах страдает другими недостатками, вытекающими из того, что все эти реализации, по сути, происходят из одной и той же реализации метода в LINPACK, а та использует пакет BLAS. Основным их недостатком является даже не наличие лишних операций, о котором уже написано в разделе «[[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]]», ибо их количество всё же невелико по сравнению с главной частью, а то, что в BLAS скалярное произведение реализовано без режима накопления. Это перечёркивает имеющиеся для метода Холецкого хорошие оценки влияния ошибок округления, поскольку они выведены как раз в предположении использования режима накопления при вычислении скалярных произведений. Поэтому тот, кто использует реализации метода Холецкого из LINPACK, LAPACK, SCALAPACK и т. п. пакетов, серьёзно рискует не получить требуемую вычислительную точность, либо ему придётся для получения хороших оценок ''одинарной точности'' использовать подпрограммы ''двойной''.

[[en:Cholesky decomposition]]

Участник:Екатерина/Алгоритм устойчивой кластеризации с использованием связей

2016-10-31T15:45:22Z

Екатерина: /* Входные и выходные данные алгоритма */

Авторы: Таратута Екатерина, Жайлауова Шынар
=Свойства и структура алгоритма=
==Общее описание алгоритма==
:Задача кластеризации заключается в следующем. Имеется множество <math>n</math> объектов <math>S=\{s_1,\ldots,s_n\}</math> и функция расстояния/сходства между объектами <math>\rho (x_i,x_j)</math>. Требуется разбить множество <math>S</math> на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из объектов, близких по метрике <math>\rho</math>, а объекты разных кластеров существенно отличались. При этом каждому объекту <math>s\in S</math> приписывается метка(номер) кластера <math>y_i</math>.
:Алгоритм кластеризации - это функция <math>f:X\to Y</math>, которая каждому объекту <math>s\in S</math> ставит в соответствие метку кластера <math>y\in Y</math>.
:Кластеризация - процесс объединения объектов, имеющих похожие характеристики, в непересекающиеся группы, называемые кластерами, так чтобы каждый кластер состоял из подобных объектов, а объекты разных кластеров отличались. При этом каждый объект характеризуется рядом признаков. Решение задачи кластеризации неоднозначно. Поэтому существует несколько типов алгоритмов кластеризации:
*эвристические графовые алгоритмы; <ref name="Voroncov">К. В. Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования, 21 декабря 2007 года</ref>
*статистические алгоритмы; <ref name="Voroncov" />
*иерархические алгоритмы.
:Иерархические алгоритмы кластеризации строят не одно разбиение на непересекающиеся классы, а систему вложенных разбиений. Различают 2 основных типа: дивизимные<ref name="Voroncov" /> и алгомеративные алгоритмы. В алгомеративной иерархической кластеризации объекты объединяются во все более и более крупные кластеры.
:Одним из алгоритмов алгомеративной иерархической кластеризации является '''алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK)''', предложенный Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories)<ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim: ROCK: A Robust Clustering Algorithm for Categorical Attributes, Volume 25, Issue 5, July 2000, Pages 345-366</ref> в 2000 году. Этот алгоритм отлично подходит для объектов с категориальными признаками, то есть признаками, принимающими свои значения из некоторого множества.
:В 2005 году была предложена быстрая версия этого ROCK-алгоритма "Quick ROCK"(QROCK).<ref>M. Duttaa, A. Kakoti Mahantab, Arun K. Pujaric QROCK: A quick version of the ROCK algorithm for clustering of categorical data</ref>

==Математическое описание алгоритма==
:Входные данные: множество объектов <math>P = \{p_1, \ldots , p_n\}</math>, целое число <math>k</math>, пороговое значение <math>\theta</math>, где <math>0\leq\theta\leq 1</math>.
:Необходимо разделить множество <math>P</math> на <math>k</math> непересекающиеся кластеры.
:'''Определение 1.''' Два объекта <math>p_i</math> и <math>p_j</math> будут соседями, если они значительно близки друг к другу, то есть <math>p_i</math> и <math>p_j</math> являются соседями, если <math>sim(p_i, p_j)\geq \theta</math>.

:Мера схожести пары объектов <math>sim(p_i, p_j)</math> может быть основана на евклидовом расстоянии, коэффициенте Жаккарда или на какой-либо другой неметрической функции схожести. Предполагается, что мера <math>sim</math> принимает значения от 0 до 1, при этом чем ближе значение меры к 1, тем больше схожи точки. Чаще всего используется мера схожести, основанная на коэффициенте Жаккарда (Jaccard coefficient)<ref>Richard O. Duda and Peter E. Hard. Pattern Classification and Scene Analysis. A Wiley-Interscience Publication, New York, 1973.</ref>: <math>sim(p_i,p_j) = \frac{|p_i\cap p_j|}{|p_i\cup p_j|}</math>, где <math>|p_i|</math> - количество атрибутов в <math>p_i</math>. Чем больше атрибутов в <math>p_i</math> и <math>p_j</math> похожи, тем больше значение <math>|p_i\cap p_j|</math>. Деление его на <math>|p_i\cup p_j|</math> гарантирует, что значение <math>\theta</math> окажется в промежутке от 0 до 1. Таким образом уравнение вычисляет похожесть двух объектов на основе схожести атрибутов, входящих в них.

:'''Определение 2.''' Назовем функцией связи между объектами функцию <math>link(p_i, p_j)</math>, определяемую как число общих соседей между объектами <math>p_i</math> и <math>p_j</math>. Из определения следует, что чем больше значение функции связи, тем вероятнее, что объекты <math>p_i</math> и <math>p_j</math> принадлежат одному кластеру.
:'''Определение 3.''' Назовем функцией связи между кластерами функцию <math>link[C_i, C_j] = \sum_{\begin{smallmatrix}p_q\in C_i,\; p_r\in C_j\end{smallmatrix}}^{ } link(p_{q},p_r)</math>, хранящую число связей между объектами кластеров <math>C_i</math> и <math>C_j</math>.

:'''Определение 4.''' Целевая функция качества, использующаяся при выборе кластеров для объединения:
:<math> g(C_i, C_j) = \frac{link[C_i,C_j]}{(n_i + n_j)^{1 + 2f(\theta )} - n_i^{1+2f(\theta )} - n_j^{1+2f(\theta )}}</math>, где <math>n_i</math> - число объектов в кластере <math>C_i</math>, функция <math>f(\theta )</math> выбирается пользователем, обычно <math>f(\theta ) = \frac{\theta - 1}{\theta + 1}</math> , <math>n_i^{1+2f(\theta )}</math> - ожидаемое число связей между парами объектов кластера <math>C_i</math>.

:'''Определение 5.''' Симметричная матрица <math>A</math> размерности <math>n</math> называется матрицей связей, где элемент матрицы <math>a_{ij} = link(p_i,p_j), i = \overline{1,n}, j = \overline{1,n}</math>

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

==Макроструктура алгоритма==
Как записано и в описании ядра алгоритма, основную часть метода составляют <math>O(n^2\log n)</math> обновлений содержимого локальной и глобальной куч.

==Схема реализации последовательного алгоритма==
:Алгоритм иерархической кластеризации ROCK представлен ниже в виде двух процедур: собственно кластеризации и вычисления связей между точками.
===Кластеризация===
:На вход алгоритм принимает некий набор <math>n</math> точек <math>S</math>. Кроме того, заданное значение <math>k</math> кластеров желаемого разбиения. Изначально каждая точка является отдельным кластером. На шаге 1 вычисляется количество связей между всеми парами точек. На шагах 2 и 3 для каждого <math>s</math> строится локальная куча <math>q[s]</math>. Локальная куча <math>q[s]</math> содержит те кластеры <math>t</math>, для которых <math>link[s,t]</math> отлична от нуля, причем кластеры в куче упорядочены в порядке убывания, на основе целевой функции качества <math>g(s,t)</math>. На шаге 4 вычисляется глобальная куча <math>Q</math>, содержащая все текущие кластеры, упорядоченные в порядке убывания на основе <math>g(s,max(q[s]))</math>. Таким образом на каждом шаге лучший кластер в <math>Q</math> и соответствующий ему максимальный кластер из <math>q</math> наилучшая пара кластеров для объединения их в один кластер.
:На шаге 5 начинает выполняться цикл <math>while</math>, до тех пор, пока в глобальной куче не останется только <math>k</math> кластеров. На каждой итерации <math>while</math>-цикла на шагах 6-9 из <math>Q</math> извлекается лучший кластер <math>u</math> и соответствующий ему максимальный кластер <math>v</math> из локальной кучи и удаляется из <math>Q</math>, так как он будет объединен с <math>u</math>, и больше в ней не нужен. Далее кластеры <math>u</math> и <math>v</math> объединяются в новый кластер <math>w</math>.
:Далее на шагах 10-15 в цикле <math>for</math> для каждого кластера, который содержит элементы <math>u</math> и <math>v</math> в своей локальной куче, они оттуда удаляются и заменяются на новый кластер <math>w</math>. Для <math>w</math> создается новая локальная куча.
:На 17 шаге новый кластер добывляется в локальную кучу, а на 18 шаге уничтожаются локальные кучи для <math>u</math> и <math>v</math>.
<math>
\begin{align}
&\mathbf{procedure}\ cluster (S,k) \\
&\mathbf{begin} \\
&1.\ \ link := compute\_links(S) \\
&2.\ \ \mathbf{for\ each}\ s\in S\ \mathbf{do} \\
&3.\ \ \ \ q[s] := build\_local\_heap(link,s) \\
&4.\ \ Q := build\_global\_heap(S,q) \\
&5.\ \ \mathbf{while}\ size(Q)\ > k\ \mathbf{do}\ \{ \\
&6.\ \ \ \ u := extract\_max(Q) \\
&7.\ \ \ \ v := max(q[u]) \\
&8.\ \ \ \ delete(Q,v) \\
&9.\ \ \ \ w := merge(u,v) \\
&10.\ \ \ \mathbf{for\ each}\ x\ \in \ q[u]\ \cup \ q[v]\\
&11.\ \ \ \ \ link[x,w] := link[x,u]\ +\ link[x,v] \\
&12.\ \ \ \ \ delete(q[x],u);\ delete(q[x],v) \\
&13.\ \ \ \ \ insert(q[x],w,g(x,w));\ insert(q[w],x,g(x,w) \\
&14.\ \ \ \ \ update(Q,x,q[x]) \\
&15.\ \ \ \} \\
&16.\ \ \ insert(Q,w,q[w]) \\
&17.\ \ \ deallocate(q[u]);\ deallocate(q[v]) \\
&18.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

===Вычисление связей===
:Для вычисления связи между всеми парами точек в <math>S</math> рассматривается матрица смежности <math>A</math> размера <math>n*n</math>, где <math>A[i,j]</math> равна 1 или 0, если <math>i</math> и <math>j</math> являются или не являются соседями соответственно. В результате умножения <math>A*A</math> в позиции <math>A[i,j]</math> получим количество связей между <math>i</math> и <math>j</math>. Для умножения матриц использовался алгоритм Штрассена.
<math>
\begin{align}
&\mathbf{procedure}\ compute\_links(S) \\
&\mathbf{begin} \\
&1.\ \ Compute\ nbrlist[i]\ for\ every\ point\ i\ in\ S \\
&2.\ \ Set\ link[i,j]\ to\ be\ zero\ for\ all\ i,j \\
&3.\ \ \mathbf{for}\ i := 1\ \mathbf{to}\ n\ \mathbf{do}\ \{ \\
&4.\ \ \ \ N := nbrlist[i] \\
&5.\ \ \ \ \mathbf{for}\ j := 1\ \mathbf{to}\ |N| - 1\ \mathbf{do} \\
&6.\ \ \ \ \ \ \mathbf{for}\ l := j+1\ \mathbf{to}\ |N|\ \mathbf{do} \\
&7.\ \ \ \ \ \ \ \ link[N[j],N[l]] := link[N[j],N[l]]+1 \\
&8.\ \ \} \\
&\mathbf{end}
\end{align}
</math>

==Последовательная сложность алгоритма==
:Вычислительная сложность алгоритма складывается из сложности инициализации, вычисления связей и собственно кластеризации.
*Инициализация глобальной кучи выполняется за время <math>O(n)</math>.
*Инициализация локальной кучи также требует <math>O(n)</math>.
*Связи между парой точек можно вычислить за <math>O(n*n^{2.37})</math> шагов, где сложность <math>O(n^{2.37})</math> - сложность умножения матриц алгоритмом Штрассена. Но это в случае, когда все являются соседями всем. Однако на практике среднее число соседей <math>m_\alpha </math> и максимальное число соседей <math>m_m</math> оказывается значительно меньше <math>n</math>. С учетом этих параметров сложность можно записать как <math>O(n m_\alpha m_m)</math>.
*В процедуре кластеризации основные вычисления происходят в цикле <math>while</math>. Сам цикл выполняется <math>O(n)</math> раз. Внутренний <math>for</math>-цикл доминирует над сложностью в <math>while</math>-цикле. Его сложность <math>O(n\log n)</math>, так как размер каждой очереди в худшем случае <math>n</math> и новый объединенный кластер <math>w</math> может нуждаться в <math>O(n)</math> локальных очередей. Следовательно весь <math>while</math>-цикл выполняется за <math>O(n^2\log n)</math>.
:Время работы ROCK-алгоритма равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>, где <math>m_m</math> - максимально возможное количество соседей, <math>m_\alpha</math> - среднее число соседей, <math>n</math> - количество объектов.

==Информационный граф==
:Опишем вершины графа алгоритма:
* <math>s_i</math> - входные данные.
* <math>CML</math> - процедура, вычисляющая матрицу связей.
* <math>BLH</math> - функция, строящая начальную локальную очередь для объекта <math>s_i</math>.
* <math>BGH</math> - строит начальную глобальную очередь входных объектов.
* <math>EM</math> - достает первый кластер из кучи.
* <math>DL</math> - удаляет кластер из кучи.
* <math>MG</math> - производит слияние двух кластеров.
* <math>L</math> - сумма двух чисел.
* <math>IN</math> - добавляет в кучу новый элемент учитывая целевую функцию качества.
* <math>U</math> - обновление кучи учитывая целевую функцию качества.
* <math>FR</math> - удаление кучи.
[[File:2.png]]
:Как видно из графа, алгоритм имеет довольно много узких мест. CML - будет записывать данные в одну и ту же матрицу. BGH - функция, строящая глобальную очередь из объектов. Вообще говоря части функций CML и BGH можно распараллелить изнутри, но об этом в следующем разделе.
:Также в программе есть вложенные циклы. Внутренний цикл мы можем выполнять параллельно, но вынуждены на каждой итерации делать синхронизацию. Внешний же цикл распараллелить не получится, так как там находятся зависимые по данным операции.

==Ресурс параллелизма алгоритма==
:Как видно из графа алгоритма, в алгоритме устойчивой кластеризации с использованием связей довольно сильная зависимость по данным. Параллельно обработать можно некоторые отдельные участки кода и только при больших объемах входных данных.
:В частности можно выполнять параллельно построение начальной локальной кучи (функция <math>build\_local\_heap</math>). Т.е. для входа размерности <math>n</math> и <math>p</math> процессов, каждый посчитает <math>\frac{n}{p}</math> локальных куч.
:Еще можно выполнять параллельно цикл, связанный обновлением матрицы связей, локальной и глобальной кучи после проведения операции слияния. Но после каждой итерации необходимо делать барьерную синхронизацию для операции <math>update</math>, которая обновляет глобальную кучу.
:Как видно из пункту 1.6 сложность последовательного алгоритма была равна <math>O(n^2+nm_m m_\alpha + n^2\log n)</math>. С учетом распараллеливания описанных выше участков кода на <math>p</math> процессов, теоретически можно получить время выполнения <math>O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})</math>.

:Также стоит отметить, что можно распараллелить процедуру <math>compute\_links</math>, которая умножает матрицы алгоритмом Штрассена. Данный алгоритм имеет смысл выполнять параллельно только если порядок матрицы не менее 1287<ref>Малашонок Г. И., Аветисян А. И., Валеев Ю. Д., Зуев М. С.: Параллельные алгоритмы компьютерной алгебры, Труды Института системного программирования РАН, Выпуск 2, том 8, 2004 </ref>.
:Функции <math>build\_local\_heap</math> и <math>build\_global\_heap</math> содержат в себе задачу сортировки, которую также можно выполнить параллельно согласно http://www.intuit.ru/studies/courses/1156/190/lecture/4958<ref>http://www.intuit.ru/studies/courses/1156/190/lecture/4958</ref> или М. В. Якобовский "Введение в параллельные методы решения задач: Учебное пособие"<ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2013. – 328 с., илл. – (Серия «Суперкомпьютерное образование») ISBN 978-5-211-06382-2</ref>.

:Их распараллеливание также может дать некоторое ускорение выполнению алгоритма, но обе функции выполняются ровно один раз.

==Входные и выходные данные алгоритма==
:'''Входные данные:''' на вход подается <math>n</math> объектов и <math>k</math> - количество кластеров, на которое необходимо разделить объекты и некоторое пороговое значение <math>\theta</math>, принимающее значение от 0 до 1.
:Задаются входные данные в частном случае в виде массива длины <math>n</math>, но так как вообще говоря данные могут иметь не один атрибут, потребуется матрица размера <math>n*r</math>, состоящей из 0 и 1, где <math>r</math> - количество признаков у объектов, а 0 и 1 стоят в зависимости от того, есть ли такой атрибут у данного объекта или нет.
:'''Выходные данные:''' Группа кластеризованных данных.
:Выходные данные представлены в виде массива из <math>n</math> элементов, где каждому элементу сопоставлен номер кластера, в который он попал.

:'''Входные данные:''' на вход подается матрица <math>A</math> размера <math>n\times r</math>, где <math>n</math> - число объектов, <math>r</math> - количество признаков у объектов. Элемент <math>a[i,j] = 1:</math> если <math>i-</math>ый объект обладает <math>j</math>-ым атрибутом, иначе - <math>a[i,j] = 0:</math>.

==Свойства алгоритма==
:Отношение последовательной и параллельной сложностей: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{O(\frac{n^2}{p}+nm_m m_\alpha + \frac{n^2\log n}{p})}</math>.
:Алгоритм является детерменированным.
:Вычислительная сложность: <math>\frac{O(n^2+nm_m m_\alpha + n^2\log n)}{2n+2}</math>.
:ROCK-алгоритм хорошо подходит для категорийных данных, таких как ключевые слова, булевские атрибуты, перечисления и т.п. Он хорошо масштабируем, авторы алгоритма создавали его так, чтобы он хорошо работал на больших объемах данных.

=Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
:Алгоритм устойчивой кластеризации с использованием связей реализован в библиотеке CBA в июне 2016 года.
:Также он реализован в feed4weka - библиотеке, содержащей алгоритмы для кластеризации данных.

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