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

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

2016-12-21T02:52:11Z

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

{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering pyclustering], выполненная на C++. Для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

Метод ''calculate_links'' в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась. Для наглядности исходный код метода приведен ниже:
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
#pragma omp parallel for reduction(+:number_links)
for (size_t ii = 0; ii < cluster1.size(); ++ii) {
for (size_t jj = 0; jj < cluster2.size(); ++jj) {
std::size_t i = cluster1[ii];
std::size_t j = cluster2[jj];
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
}
}
}
</source>

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

Метод ''create_adjacency_matrix'' также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения. Распараллеленный код приведен ниже для справки.
<source lang="c++" line>
void rock::create_adjacency_matrix(const dataset & p_data) {
m_adjacency_matrix = adjacency_matrix(p_data.size());

int procNum = 0;
MPI_Comm_size(MPI_COMM_WORLD, &procNum);

const size_t mSize = m_adjacency_matrix.size();
const size_t q = mSize / procNum;
const size_t blockSize = (mSize % procNum == 0) ? q : (q + 1);

MPI_Request reqs[mSize];
MPI_Request sendReqs[blockSize];
MPI_Status stats[mSize];

if (m_rank == 0) {
for (size_t i = 0; i < blockSize; ++i) {
reqs[i] = MPI_REQUEST_NULL;
}
for (size_t r = 1; r < procNum; ++r) {
for (size_t i = r * blockSize; i < (r + 1) * blockSize && i < mSize; ++i) {
MPI_Irecv(&(m_adjacency_matrix.raw_data()[i][0]), mSize, MPI_DOUBLE, r, 0, MPI_COMM_WORLD, reqs + i);
}
}
}

for (size_t i = m_rank * blockSize; i < (m_rank + 1) * blockSize && i < mSize; ++i) {
for (size_t j = i + 1; j < mSize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);
if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}

if (m_rank == 0) {
MPI_Waitall(mSize, reqs, stats);
}
else {
size_t j = 0;
for (size_t i = m_rank * blockSize; i < (m_rank + 1) * blockSize && i < mSize; ++i, ++j) {
MPI_Isend(&(m_adjacency_matrix.raw_data()[i][0]), mSize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, sendReqs + j);
}
for (; j < blockSize; ++j) {
sendReqs[j] = MPI_REQUEST_NULL;
}
MPI_Waitall(blockSize, sendReqs, stats);
}
}
</source>

TODO: 2 графика

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-12-21T02:43:36Z

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

{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|-
| EngyTime
| 2728.09
| 4096
| 13
|-
| GolfBall
| 2429.69
| 4002
| 13
|}

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

Метод ''calculate_links'' в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже:
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
#pragma omp parallel for reduction(+:number_links)
for (size_t ii = 0; ii < cluster1.size(); ++ii) {
for (size_t jj = 0; jj < cluster2.size(); ++jj) {
std::size_t i = cluster1[ii];
std::size_t j = cluster2[jj];
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
}
}
}
</source>

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

Метод ''create_adjacency_matrix'' также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения. Распараллеленный код приведен ниже для справки.
<source lang="c++" line>
void rock::create_adjacency_matrix(const dataset & p_data) {
m_adjacency_matrix = adjacency_matrix(p_data.size());

int procNum = 0;
MPI_Comm_size(MPI_COMM_WORLD, &procNum);

const size_t mSize = m_adjacency_matrix.size();
const size_t q = mSize / procNum;
const size_t blockSize = (mSize % procNum == 0) ? q : (q + 1);

MPI_Request reqs[mSize];
MPI_Request sendReqs[blockSize];
MPI_Status stats[mSize];

if (m_rank == 0) {
for (size_t i = 0; i < blockSize; ++i) {
reqs[i] = MPI_REQUEST_NULL;
}
for (size_t r = 1; r < procNum; ++r) {
for (size_t i = r * blockSize; i < (r + 1) * blockSize && i < mSize; ++i) {
MPI_Irecv(&(m_adjacency_matrix.raw_data()[i][0]), mSize, MPI_DOUBLE, r, 0, MPI_COMM_WORLD, reqs + i);
}
}
}

for (size_t i = m_rank * blockSize; i < (m_rank + 1) * blockSize && i < mSize; ++i) {
for (size_t j = i + 1; j < mSize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);
if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}

if (m_rank == 0) {
MPI_Waitall(mSize, reqs, stats);
}
else {
size_t j = 0;
for (size_t i = m_rank * blockSize; i < (m_rank + 1) * blockSize && i < mSize; ++i, ++j) {
MPI_Isend(&(m_adjacency_matrix.raw_data()[i][0]), mSize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, sendReqs + j);
}
for (; j < blockSize; ++j) {
sendReqs[j] = MPI_REQUEST_NULL;
}
MPI_Waitall(blockSize, sendReqs, stats);
}
}
</source>

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-18T19:10:12Z

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

{{Assignment}}
{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|-
| EngyTime
| 2728.09
| 4096
| 13
|-
| GolfBall
| 2429.69
| 4002
| 13
|}

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

Метод ''calculate_links'' в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже:
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод ''create_adjacency_matrix'' также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-18T19:05:24Z

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

{{Assignment}}
{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|-
| EngyTime
| 2728.09
| 4096
| 13
|-
| GolfBall
| 2429.69
| 4002
| 13
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже:
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-18T19:04:16Z

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

{{Assignment}}
{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|-
| EngyTime
| 2728.09
| 4096
| 13
|-
| GolfBall
| 2429.69
| 4002
| 13
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-15T13:22:26Z

Lkruglov:

{{Assignment}}
{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-14T17:48:17Z

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

{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-14T17:47:10Z

Lkruglov: /* Литература */

{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело, в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

[6] Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.

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

2016-11-14T17:46:08Z

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

{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов» [6] [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело, в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-11-14T17:37:39Z

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

{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

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

Для оценки производительности была выбрана реализация из [https://github.com/annoviko/pyclustering annoviko/pyclustering], выполненная на C++. Исходная версия алгоритма показала следующие результаты. Здесь и далее для тестирования использовался суперкомпьютер «Ломоносов».

{| class="wikitable"
|-
! Название теста
! Время выполнения (сек)
! Количество точек
! Количество кластеров
|-
| Chainlink
| 312.7
| 1500
| 2
|-
| TwoDiamonds
| 160.4
| 1270
| 2
|-
| Target
| 142.9
| 1150
| 6
|-
| WingNut
| 1324.6
| 2400
| 2
|}

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

Метод calculate_links в оригинальной версии отвечал за 20-25% общего времени выполнения. После распараллеливания на OpenMP производительность только ухудшилась, тот же результат принесло использование MPI. Для наглядности исходный код метода приведен ниже.
<source lang="c++" line>
size_t rock::calculate_links(const cluster & cluster1, const cluster & cluster2) const {
size_t number_links = 0;
for (auto i : cluster1)
for (auto j : cluster2)
number_links += (size_t) m_adjacency_matrix.has_connection(i, j);
return number_links;
}
</source>

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

Метод create_adjacency_matrix также был распараллелен с помощью MPI. К качественному ускорению это не привело, в первую очередь из-за того, что на использованных тестах среднее время выполнения этого метода занимало около 0.004% от общего времени выполнения.

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

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-28T13:01:54Z

Lkruglov:

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK_graph.png|400px|thumb|right|Визуализация информационного графа для n = 100 исходных точек и k = 8 требуемых кластеров]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-26T06:40:30Z

Lkruglov: Новая страница: «Добрый день! Замечания к статье исправлены (Участники: Круглов Леонид, Баранов Максим/Ал…»

Добрый день! Замечания к статье исправлены (Участники: Круглов Леонид, Баранов Максим/Алгоритм устойчивой кластеризации с использованием связей)

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

2016-10-26T06:38:33Z

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

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

2016-10-26T06:34:53Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''QS''' - созданиение локальной кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции
* '''K''' - полученный кластер

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:05:59Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:04:44Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

:<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>.

Отношение последовательной и параллельной сложности:

:<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:03:30Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оценка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:03:18Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

:<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:02:50Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

:<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

:<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T22:02:05Z

Lkruglov: /* Математическое описание алгоритма */

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

:<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

:<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

:<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:33:02Z

Lkruglov:

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если для вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:30:56Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если в качестве алгоритма вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным.

Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{O(n^{2,37} + n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_{L_p}</math> - сложность параллельного алгоритма подсчета числа связей (оценки приведены для использования алгоритма Копперсмита—Винограда для вычисления количества связей).

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:18:12Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если в качестве алгоритма вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:14:31Z

Lkruglov:

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>O(n^{2,37} + n^2\log n)</math>, если в качестве алгоритма вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:05:01Z

Lkruglov:

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>\frac{O(n^{2,37} + n^2\log n)}{2n+2}</math>, если в качестве алгоритма вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-24T20:00:49Z

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

{{Assignment}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math>\frac{O(n^{2,37}) + O(n^2\log n)}{2n+2}</math>, если в качестве алгоритма вычисления количества связей используется алгоритм Копперсмита—Винограда
| input_data = Вектор из <math>n</math> точек в виде векторов характеристик произвольного вида, дополнительно одно вещественное и одно челое число <math>k</math>
| output_data = Сгруппированные в <math>k</math> кластеров <math>n</math> классифицируемых точек представленных индексами во входном векторе
}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1] (псевдокод):
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = O(n^{2,37} + n^2\log{n})</math>

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a}))</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Пороговое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:59:59Z

Lkruglov:

{{Assignment}}
Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = C_L + O(n^2\log{n})</math>,

где <math>C_L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:57:09Z

Lkruglov:

Авторы: [[Участник:LKruglov|Круглов Л. В.]](1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = C_L + O(n^2\log{n})</math>,

где <math>C_L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:56:38Z

Lkruglov:

Авторы: [[Участник:LKruglov|Круглов Л. В.]]1.1,1.2,1.3,1.6,1.8,1.10), [[Участник:Innot|Баранов М. С.]](1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.7)
== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = C_L + O(n^2\log{n})</math>,

где <math>C_L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>C_{t_p} = {C_{L_p}} + O(\frac{n^2\log n}{p})</math>,

где <math>{C_{L_p}}</math> - оцентка времени работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{C_L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{C_L + O(n^2\log n)}{{C_{L_p}} + O(\frac{n^2\log n}{p})}</math>,

где <math>C_L</math> и <math>C_{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:45:30Z

Lkruglov: /* Программная реализация алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, оценка времени выполнения алгоритма <math>C_t</math> задается следующей формулой:

<math>C_t = C_L + O(n^2\log{n})</math>,

где <math>C_L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и задается формулой:

<math>C_s = O(min(n^2, n{m_m}{m_a}))</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:41:17Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, временная сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и также равняется <math>O(min(n^2, n{m_m}{m_a})</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>n</math> точек, распределенных по <math>k</math> кластерам

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:38:34Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух частей:
# Подсчет количества связей между точками;
# Итеративное объединение кластеров.

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, временная сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и также равняется <math>O(min(n^2, n{m_m}{m_a})</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:36:13Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, временная сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и также равняется <math>O(min(n^2, n{m_m}{m_a})</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения:

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление кучи/куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:35:43Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятий связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, временная сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

Пространственную сложность подсчета количества связей можно оценить как <math>O(min(n^2, n{m_m}{m_a})</math>. Так как при слиянии двух кластеров размер новой кучи не превосходит суммы размеров куч объединяемых кластеров, то пространственная сложность итерационной части алгоритма зависит только от размеров исходных куч и также равняется <math>O(min(n^2, n{m_m}{m_a})</math>.

=== Информационный граф ===
[[Файл:ROCK.info.graph.png|400px|thumb|right|Визуализация информационного графа]]
На рисунке представлен информационный граф алгоритма. Используются следующие обозначения.

* '''I''' - входные данные
* '''M''' - вычисление матрицы связей
* '''Qs''' - вычисление локальных кучи
* '''QG''' - создание глобальной кучи
* '''HG''' - взятие элемента/элементов из кучи
* '''HD''' - удаление элемента из кучи
* '''HI''' - добавление элемента в кучу
* '''HU''' - обновление кучи
* '''HX''' - удаление кучи/куч
* '''CM''' - слияние кластеров
* '''A''' - арифметические операции

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:24:05Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3
# Пакет [https://cran.r-project.org/web/packages/cba/index.html CBA] из репозитория CRAN содержит реализацию на R под GPL 2
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:21:00Z

Lkruglov: /* Литература */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

== Литература ==
[1] Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2] Coppersmith D., Winograd S. Matrix multiplication via arithmetic progressions //Proceedings of the nineteenth annual ACM symposium on Theory of computing. – ACM, 1987. – С. 1-6.

[3] Thomas H. Cormen et al. Introduction to algorithms. – Cambridge : MIT press, 2001. – Т. 6.

[4] Guha S., Rastogi R., Shim K. Cure: an efficient clustering algorithm for large databases //Information Systems. – 2001. – Т. 26. – №. 1. – С. 35-58.

[5] Vitter J. S. Random sampling with a reservoir //ACM Transactions on Mathematical Software (TOMS). – 1985. – Т. 11. – №. 1. – С. 37-57.

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

2016-10-15T20:15:24Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда [2], вычислительная сложность которого равна <math>O(n^{2,37})</math> (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

== Литература ==
[1]Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2]

[3]

[4]

[5]

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

2016-10-15T20:14:47Z

Lkruglov: /* Литература */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [2] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

== Литература ==
[1]Guha S., Rastogi R., Shim K. ROCK: A robust clustering algorithm for categorical attributes //Data Engineering, 1999. Proceedings., 15th International Conference on. – IEEE, 1999. – С. 512-521.

[2]

[3]

[4]

[5]

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

2016-10-15T20:13:04Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [2] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [4]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [5].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

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

2016-10-15T20:12:16Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [2] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [3]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

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

2016-10-15T20:11:40Z

Lkruglov: /* Свойства и структура алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

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

2016-10-15T20:10:45Z

Lkruglov: /* Свойства и структура алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK [1]) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

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

2016-10-15T20:10:01Z

Lkruglov: /* Программная реализация алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

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

2016-10-15T20:09:25Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T20:06:24Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество кластеризуемых точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T20:05:17Z

Lkruglov: /* Математическое описание алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T20:05:05Z

Lkruglov: /* Математическое описание алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}} \qquad(1)</math></math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T20:04:51Z

Lkruglov: /* Математическое описание алгоритма */

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}}</math> \qquad(1)</math>

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T20:02:42Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}}</math> (1)

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

<math>{L_p} + O(\frac{n^2\log n}{p})</math>,

где <math>{L_p}</math> - время работы выбранного параллельного алгоритма подсчета числа связей.

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.

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

2016-10-15T19:58:18Z

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

== Общее описание алгоритма ==
=== Свойства и структура алгоритма ===
В связи с наличием огромного количества накопленной информации задача добычи данных становится все более важной. Кластеризация позволяет распределять данные по группам (кластрерам) так, что в каждой группе данные обладают схожими характеристиками, а в разных группах характеристики различаются.

Алгоритм устойчивой кластеризации с использованием связей (robust clustering using links, ROCK) построен на основе понятия связей между кластеризуемыми точками и их соседства. Две точки считаются соседями, если являются достаточно близким (схожими): <math>sim({p_i}, {p_j}) >= \theta</math>, где <math>\theta</math> - заданное пороговое значение в интервале <math>(0, 1)</math>. Связь <math>link({p_i}, {p_j})</math> между двумя точками определяется как число общих соседей между точками <math>{p_i}</math> и <math>{p_j}</math>. Таким образом, чем большее значение функции связи для двух точек, тем более вероятно они принадлежат одному кластеру.

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

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

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

<math>E_l = \sum_{i=1}^k n_i * \sum_{p_q, p_r \in C_i} \frac{link(p_q, p_r)}{n_i^{1+2f(\theta)}}</math> (1)

Данная функция отличается от простой суммы связей для каждого кластера, так как не обеспечивает распределение точек, имеющих мало связей между собой, по разным кластерам. Поэтому действительную сумму связей в кластере следует разделить на ожидаемую сумму связей. Функция <math>f(\theta)</math> задается пользователем исходя из свойств обрабатываемых данных и ожидаемого характера кластеризации. Она должна обладать следующим свойством: каждая точка, принадлежащая кластеру <math>C_i</math>, имеет приблизительно <math>n_i^{f(\theta)}</math> соседей в этом кластере.

Связь между двумя кластерами определяется как

<math>link({C_i}, {C_j}) = \sum^{}_{{p_q}\in{C_i}, {p_r}\in{C_j}}{link[{C_i}, {C_j}]}</math>

Тогда для выбора кластеров для объединения определяется целевая функция качества:

<math>g(C_i, C_j) = \frac{link[C_i, C_j]}{(n_i+n_j)^{1+2f(\theta)} - f_i^{1+2f(\theta)} - f_j^{1+2f(\theta)}}</math>

Аналогично целевой функции (1) значение связи между двумя кластерами делится на ожидаемое число связей между кластерами.

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

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

Итеративная часть алгоритма может быть реализована с помощью структуры данных куча. На каждой итерации с каждым кластером <math>i</math> связана своя куча <math>q[i]</math>, содержащая все связанный с ним кластеры, упорядоченная по убыванию функции качества. Также поддерживается глобальная куча <math>Q</math>, содержащая все кластеры <math>j</math>, упорядоченные по мере убывания функции качества <math>g(j, max(q[j]))</math>, где <math>max(q[j])</math> - это вершина кучи <math>q[j]</math>. Тогда на каждой итерации объединяются кластер <math>j</math> с вершины глобальной кучи и кластер <math>q[j]</math>. После объединения необходимо обновить все кучи, содержащие объединенные кластеры, обновить глобальную кучу <math>Q</math> и создать кучу для нового кластера. Итеративный процесс продолжается до тех пор, пока в глобальной куче <math>Q</math> не останется требуемое число кластеров.

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

=== Схема реализации последовательного алгоритма ===
Следующая схема последовательного алгоритма представлена в работе [1]:
<source lang="pascal" line>
procedure cluster(S, k)
begin
link := compute_links(S)
for s in S do
begin
q[s] := build_local_heap(link, s)
end
Q := build_global_heap(S, q)
while size(Q) > k do
begin
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x in q[u] or q[v] do
begin
link[x, w] := link[x, u] + link[x, v]
delete(q[x], u)
delete(q[x], v)
insert(q[x], w, g(x, w))
insert(q[w], x, g(x, w))
update(Q, x, q[x])
end
insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end

</source>

=== Последовательная сложность алгоритма ===
Для вычисления количества связей с помощью возведения матрицы в квадрат можно воспользоваться алгоритмом Копперсмита—Винограда, вычислительная сложность которого равна <math>O(n^{2,37})</math> [3] (<math>n</math> - количество точек). Для случаев разреженной матрицы смежности в работе [1] описывается алгоритм, имеющий сложность <math>O(n^2 + n{m_m}{m_a})</math>, где <math>{m_a}</math> и <math>{m_m}</math> - это среднее и максимальное количество соседей точки соответственно.

Каждая куча может быть построена за время <math>O(n)</math> [4]. Внешний цикл итерационной части алгоритма исполняется <math>O(n)</math> раз. Так как на очередной итерации размер каждой локальной кучи в худшем случае может равняться <math>n</math>, то новый кластер должен быть помещен в <math>n</math> локальных куч, что дает временную сложность вложенного цикла <math>O(n\log{n})</math>. Таким образом, сложность внешнего цикла в худшем случае будет <math>O(n^2\log{n})</math>.

Итак, сложность описанного алгоритма будет

<math>L + O(n^2\log{n})</math>,

где <math>L</math> - сложность алгоритма вычисления количества связей.

=== Информационный граф ===
На рисунке представлен информационный граф алгоритма. Блок L соответствует предварительному подсчету числа связей точек, блок QLs и QG - созданию локальных и глобальной куч соответственно, блок M - слиянию кластеров, блок U - обновлению куч.

TODO

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

TODO?

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

1. Множество <math>n</math> точек, которые необходимо кластеризовать
2. Порогрвое значение <math>\theta</math> из интервала <math>(0, 1)</math>
3. Требуемое число кластеров <math>k</math>

Также к входным данным относится информация о характеристиках точек (например в виде таблицы булевых значений принадлежности характеристик точкам).

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

1. <math>k</math> полученных кластеров

=== Свойства алгоритма ===
Одним из важных вопросов, влияющих на эффективность алгоритма, является выбор исходных точек. Подход к выбору размера исходного набора точек, достаточного для качественной кластеризации, описывается в работе [5]. Использование случайной стратегии выбора исходных точек помогает алгоритму кластеризации отбрасыванием выпадающих точек (то есть точек, слабо связанных с другими точками). Различные алгоритмы случайного выбора исходных точек рассматриваются в работе [6].

Обработка выпадающих точек в рассматриваемом алгоритме обеспечивается выбором порогового значения <math>\theta</math>. Также такие точки могут быть принудительно отброшены на последних итерациях алгоритма.

После завершения кластеризации выбранных исходных точек, оставшиеся точки распределяются по кластерам следующим образом. Из каждого кластера выбирается набор точек <math>{L_i}</math>, и очередная точка <math>p</math> помещается в кластер <math>i</math>, если <math>p</math> имеет наибольшее число соседей множеством <math>{L_i}</math>.

Рассматриваемый алгоритм является детерминированным. Его вычислительная мощность равна

<math>\frac{L + O(n^2\log n)}{2n+2}</math>,

отношение последовательной и параллельной сложности:

<math>\frac{L + O(n^2\log n)}{{L_p} + O(\frac{n^2\log n}{p})}</math>,

где <math>L</math> и <math>{L_p}</math> - соответственно последовательная и параллельная сложность алгоритма подсчета числа связей.

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

# Библиотека [https://github.com/annoviko/pyclustering annoviko/pyclustering] включает реализации для Python и C++ под GPL 3.
# Пакет CBA из репозитория CRAN содержит реализацию на R под GPL 2: [https://cran.r-project.org/web/packages/cba/index.html]
# Библиотеки [http://www.cs.waikato.ac.nz/ml/weka/ Weka] и [https://sourceforge.net/projects/feed4weka/files/?source=navbar feed4weka] содержат реализацию для Java под GPL 2.