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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-18T07:26:11Z

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

{{Assignment}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Суммарный объем входных данных равен <math> O(N^2) </math> , число операций алгоритма '''PAM''' равно <math> O(K*N^2*\Tau) </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма, <math> N </math> - число точек. Тогда вычислительная мощность алгоритма '''PAM''' равна <math>O(K*\Tau)</math>.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-18T07:25:40Z

Denemmy:

{{Assignment}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Суммарный объем входных данных равен <math> O(N^2) </math> , число операций алгоритма '''PAM''' равно <math> O(K*N^2*\Tau) </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма, <math> N </math> - число точек. Тогда вычислительная мощность алгоритма '''PAM''' равна <math>K*\Tau </math>.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-18T07:24:09Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Суммарный объем входных данных равен <math> O(N^2) </math> , число операций алгоритма '''PAM''' равно <math> O(K*N^2*\Tau) </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма, <math> N </math> - число точек. Тогда вычислительная мощность алгоритма '''PAM''' равна <math>K*\Tau </math>.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-18T07:14:44Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-18T07:14:13Z

Denemmy:

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-16T11:38:46Z

Denemmy:

{{Assignment}}
{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-16T11:38:20Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-16T11:38:09Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

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

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-16T11:27:38Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

Исследование проводилось на суперкомпьютере '''"Ломоносов"'''. Алгоритм реализован с использованием технологии '''MPI'''.

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

В экспериментах была использована сторонняя реализация алгоритма, с небольшими изменениями она выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-14T10:31:26Z

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

{{Assignment}}
{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

Исследование проводилось на суперкомпьютере '''"Ломоносов"'''. Алгоритм реализован с использованием технологии '''MPI'''.

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

Реализация алгоритма, которая использовалась в экспериментах выложена в репозитории[https://denemmy@bitbucket.org/denemmy/pam.git]

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-14T10:23:08Z

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

{{Assignment}}
{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

Исследование проводилось на суперкомпьютере '''"Ломоносов"'''. Алгоритм реализован с использованием технологии '''MPI'''.

Данные были сгенерированы в '''Matlab'е''' случайным образом. Количество кластеров равно '''16''', каждый кластер был промоделирован нормальным распределением с некоторыми случайными значениями среднего и среднеквадратического отклонения. Размерность данных равна '''2''', а число точек на каждый кластер было достаточно большим для проведения экспериментов с различными значениями размерности матрицы расстояний. Пример сгенерированных данных показан на рисунке 3.

[[Файл:16_clusters.jpg|thumb|center|512px|Рисунок 3. Пример сгенерированных данных.]]

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

Значения размерности: [2500, 2000, 1500, 1000, 500, 200, 150, 100, 50]
Значения числа процессоров: [500, 400, 256, 128, 64, 32, 16, 8, 4, 1]

Полученные графики производительности и эффективности представлены на рисунках 4 и 5 соответственно.

[[Файл:GFLOPS.png|thumb|center|512px|Рисунок 4. Зависимость производительности реализации параллельного алгоритма от размера матрицы и числа процессоров]]
[[Файл:EFF.png|thumb|center|512px|Рисунок 5. Зависимость эффективности реализации параллельного алгоритма от размера матрицы и числа процессоров.]]

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

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-11T07:53:29Z

Denemmy:

{{Assignment}}
{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-11T07:53:18Z

Denemmy:

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

{{Assignment}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:53:39Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:53:25Z

Denemmy: /* Общее описание алгоритма */

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:<ref>Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</ref>

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:52:08Z

Denemmy: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'' <ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:51:52Z

Denemmy: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма''<ref>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.:</ref>

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:50:31Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы. <ref>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</ref>

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:47:30Z

Denemmy: /* Общее описание алгоритма */

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:46:46Z

Denemmy: /* Общее описание алгоритма */

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw)<ref>Kaufman, L. and Rousseeuw, P.J., Clustering by means of Medoids. In: Y. Dodge and North-Holland, editor. Statistical Data Analysis Based on the L1-Norm and Related Methods. Springer US; 1987, p. 405–416.</ref>. и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:43:27Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw) и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP_2.png|thumb|center|800px|Рисунок 2. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:43:12Z

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

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw) и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD_2.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP.png|thumb|center|800px|Рисунок 1. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-11-07T13:32:49Z

Denemmy:

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

Оба автора в равной мере участвовали в написании, обсуждении и оформлении содержимого статьи.

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw) и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP.png|thumb|center|800px|Рисунок 1. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T20:59:20Z

Denemmy:

{{Assignment}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(T*K*N^2)</math>
| input_data = <math> N*(N-1)/2 + 2 </math>
| output_data = <math> N </math>
}}

Авторы: [[Участник:Denemmy|Галеев Д.Ф]], [[Участник:zaputlyaev|Запутляев И.]]

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

=== Общее описание алгоритма ===

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

Алгоритм '''Partitioning Around Medoids''' ('''PAM''') был создан Леонардом Кауфманом (Leonard Kaufman) и Питером Руссивом (Peter J. Rousseeuw) и он очень похож на алгоритм K-means, в основном потому, что оба являются алгоритмами кластеризации, другими словами, оба разделяют множество объектов на группы (кластеры) и работа обоих основана на попытках минимизировать ошибку, но PAM работает с медоидами - объектами, являющимися частью исходного множества и представляющими группу, в которую они включены, а K-means работает с центроидами - искусственно созданными объектами, представляющими кластер.

Алгоритм PAM разделяет множество из N объектов на K кластеров, где и множество объектов, и число K являются входными данными алгоритма. Алгоритм работает с матрицей расстояний, его цель - минимизировать расстояние между представителями каждого кластера и его членами. Алгоритм использует следующую модель для решения задачи:

<math>F(x)=minimize \sum_{i=1}^{N}\sum_{j=1}^{N} d(i,j)z_{ij}</math>

При этом:

1. <math> \sum_{i=1}^N {z_{ij} = 1} , j = 1,2,...,N</math>;

2. <math>z_{ij} \le y_i , i, j = 1,2,...,N</math>;

3. <math>\sum_{i=1}^N {y_i = K} , K - </math> число кластеров;

4. <math>y_i , z_{ij} \in \{ 0,1 \} , i, j = 1,2,...,N</math>.

где функция <math>F(x)</math> - целевая минимизируемая функция, <math>d(i,j)</math> - мера расстояния между объектами <math>i</math> и <math>j</math>, <math>z_{ij}</math> - переменная, которая гарантирует, что расстояние только между объектами из одного кластера будет вычислено в целевой функции. Остальные выражения являются следующими ограничениями:

1. Каждый объект принадлежит одному и только одному кластеру;

2. Каждый объект относится к медоиде, представляющей его кластер;

3. Есть в точности K кластеров;

4. Решающая переменная принимает значения 0 или 1.

PAM может работать с двумя типами входных данных:

1. С матрицей объектов и значениями ее переменных;

2. С матрицей расстояний.

Алгоритм имеет две фазы:

Фаза '''Build''':

1. Выбрать K объектов в качестве медоид;

2. Построить матрицу расстояний, если она не была задана;

3. Отнести каждый объект к ближайшей медоиде;

Фаза '''Swap''':

4. Для каждого кластера найти объекты, снижающие среднее расстояние, и если такие объекты есть, выбрать те, которые снижают его сильней всего, в качестве медоид;

5. Если хотя бы одна медоида поменялась, вернуться к шагу 3, иначе завершить алгоритм.

=== Математическое описание алгоритма ===
''Обозначения'':

1. <math>M = \{ x_{m_1}, x_{m_2}, ... , x_{m_s} \} - </math> множество медоид;

2. <math>L = \{ x_{l_1}, x_{l_2}, ... , x_{m_t} \} - </math> множество объектов <math>x_i</math>, не являющихся медоидами;

3. <math>F_{M,L} = \sum_{j = 1}^{N} \min_{ x_{m_q} \in M} d(x_{m_q},x_{l_j}) - </math> целевая функция.

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

1. Множество <math>X = \{ x_{1}, x_{2}, \dots, x_{N} \}</math> объектов <math>x_i</math>, каждый из который задается <math>P</math> вещественными значениями;

2. Симметрическая матрица <math>D</math>, элементы <math>d_{ij} = d(x_i,x_j)</math> которой являются расстояниями между объектами <math>x_i</math> и <math>x_j</math>;

3. Число кластеров <math>K \le N</math>;

4. Метрика <math>d_{ij} = d(x_i,x_j)</math>, задающая расстояние между объектами <math>x_i</math> и <math>x_j</math>.

''Вычислительные формулы метода'':

Фаза '''Build''':

Представляет из себя выбор K медоид за K последовательных шагов:

1. <math>M_0 = \varnothing, L_0 = X</math>;

2. <math>x_{m_i} = \arg \min_{x_{l_q} \in L_0} \sum_{j = 1}^N d(x_{l_q},x_j), L_1 = L_0 \backslash \{x_{m_i}\}, M_1 = M_1 \cup \{x_{m_i}\}, i=1 \dots N </math>;

Фаза '''Swap''':

Представляет из себя итерационный процесс.

1. Начальное приближение: <math>M_0 = M_{BUILD}, L_0 = L_{BUILD}</math>;

2. Множественные вычисления значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>;

3. Изменение множеств в соответствии с выбранной парой <math>(x_{m_t}, x_{l_q})</math>:

<math>M_i = M_{i-1} \backslash \{x_{m_t}\} \cup \{x_{l_q}\} , L_i = L_{i-1} \cup \{x_{m_t}\} \backslash \{x_{l_q}\} </math>;

4. Проверка критерия останова.

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

1. <math>M = \{ x_{m_{1}}, x_{m_{2}}, ..., x_{m_{K}} \}</math> - множество медоид;

2. <math>K_{m_i} = \{ x_{l_q} \in L \| x_{m_i} = \arg \min_{x_{m_s} \in M} d(x_{l_q}, x_{m_s}) \}, i=1 \dots K, K -</math> множество искомых кластеров.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма PAM сосредоточено в стадии '''SWAP''' и состоит из вычислений значений целевой функции для различных вариантов замены текущей медоиды на новую:

<math>F = arg \min_{i \in M , j \in L} \sum_{y \in L \backslash \{j\}} {min (d(i,y),d(j,y))} </math>

=== Макроструктура алгоритма ===
Если на вход алгоритма была подана не матрица расстояний, а матрица объектов с их координатами в пространстве <math>R^P</math>, то операция вычисления расстояния между объектами <math>a</math> и <math>b</math> размерности <math>P</math> будет являться макрооперацией. В качестве меры расстояния может быть использована евклидова метрика:
<math> d(a,b) = \sqrt{(a_1-b_1)^2+(a_2-b_2)^2+\dots+(a_P-b_P)^2} = \sqrt{\sum_{i=1}^P (a_i-b_i)^2}</math>

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

''Псевдокод алгоритма'':

1 функция PAM(D, k, tmax=100):
2 # D - матрица расстояний, k - число кластеров, tmax - маскимальное число итераций
3 выполнить фазу BUILD, получить множество метоидов M и множество не-метоидов L
4 вычислить значение целевой функции F
5 для t = 0..tmax-1:
6 выполнить фазу SWAP, вычислить значение целевой функции F'
7 delta = F - F'
8 если delta > 0:
9 обновить множества M и L
10 F = F'
11 иначе:
12 выйти из цикла
13 вернуть М

=== Последовательная сложность алгоритма===
Обозначим количество кластеров как <math>K</math>, количество объектов как <math>N</math>, число итераций алгоритма как <math>T</math>.

На стадии '''BUILD''' каждый шаг нахождения очередного метоида имеет сложность <math>O(N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.
 Тогда стадия '''BUILD''' имеет сложность <math>O(K*N^2)</math>

На стадии '''SWAP''' вычисление целевой функции имеет сложность <math>O(K*N^2)</math> по количеству операций сложения вещественных чисел и по количеству операций сравнения двух вещественных чисел.

Таким образом алгоритм PAN имеет сложность <math>O(T*K*N^2)</math>

=== Информационный граф ===

'''Фаза BUILD'''

Общий вид информационного графа для шага t представлен на рисунке 1:

[[Файл:BUILD.png|thumb|center|800px|Рисунок 1. Информационный граф шага t фазы BUILD алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление функции ошибки, на вход подается расстояния от очередного объекта до всех остальных, а также минимальные расстояния от выбранных на данном шаге метоидов до всех остальных вершин</li>
<li>MIN<math>_s</math> - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
<li>MIN<math>_d</math> - нахождение минимальных расстояний от медоидов до остальных вершин, используется в операции SUM</li>
</ul>
Количество шагов t равно K, где K - число кластеров

'''Фаза SWAP'''

Общий вид информационного графа для итерации t представлен на рисунке 2:

[[Файл:SWAP.png|thumb|center|800px|Рисунок 1. Информационный граф итерации t фазы SWAP алгоритма.]]

''Операции''
<ul>
<li>Update<math>_M</math> и Update<math>_L</math> - операции обновления множества метоидов и не-метоидов соответственно</li>
<li>SUM - вычисление целевой функции</li>
<li>MIN - нахождение аргумента, соответствующего минимальному значению, а также само минимальное значение</li>
</ul>

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

Пусть число кластеров равно <math>K</math>, а число объектов равно <math>N</math>. Тогда параллельная сложность фазы BUILD имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Таким образом параллельная сложность фазы BUILD равна <math>O(K*N*T)</math>.

Параллельная сложность фазы SWAP имеет <math>O(K*N)</math> операций сложения и <math>O(K*N)</math> операций сравнения двух вещественных чисел. Параллельная сложность фазы SWAP равна <math>O(K*N*T)</math>.

Таким образом параллельная сложность алгоритма равна <math>O(K*N*T)</math>.

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

''Входные данные'':
* число <math>K</math> - количество кластеров;
* число <math>N</math> - количество объектов;
* вектор попарных расстояний, имеющий длину <math>N*(N-1)/2</math>, из данных чисел однозначно восстанавливается симметрическая матрица расстояний <math>D</math>
''Объём входных данных'': <math>N*(N-1)/2</math> вещественное число и <math>2</math> целых числа.

''Выходные данные'':
* K чисел <math>m_1, m_2, ..., m_K</math> - индексы объектов соответствующие метоидам;
* N-K чисел <math>k_1, k_2, ..., k_{N-K}</math> - номера кластеров для каждого объекта (кроме тех, что являются метоидами);
''Объём выходных данных'': <math>N</math> целых чисел.

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма k means равна <math>\frac{K*N^2*\Tau}{N^2} = K*\Tau </math>, где <math>K</math> – число кластеров, <math>\Tau</math> – число итераций алгоритма.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Алгоритм PAM является итерационным, количество итераций может быть ограничено сверху, однако в общем случае не фиксируется. Из-за недетермирированности выбора элементов, на которых достигается минимум целевой функции, алгоритм не является детермирированным. Однако, данный алгоритм является устойчивым, поскольку не накапливает ошибки в процессе своей работы.

Сильные стороны алгоритма:
<ul>
<li>Меньшая чувствительность к выбросам, чем k-means</li>
<li>Несложность реализации</li>
<li>
Возможность распараллеливания
Однако равномерная загрузка процессоров не всегда возможна.
</li>
</ul>
Недостатки алгоритма:
<ul>
<li>Квадратичная сложность алгоритма</li>
<li>
Количество кластеров является параметром алгоритма
Во многих задачах число кластеров может быть неизвестным.
</li>
<li>
Возможность сходимости к локальному оптимуму
Оптимальное решение не гарантировано.
</li>
</ul>

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

<ol>
<li>[http://research.omicsgroup.org/index.php/ELKI ELKI] реализует несколько вариантов алгоритма кластеризации, включая алгоритм PAM. Написан на Java</li>
<li>[http://java-ml.sourceforge.net/ Java-ML]. Включает реализацию k-metoid. Написан на Java</li>
<li>[http://research.omicsgroup.org/index.php?title=Julia_language&action=edit&redlink=1 Julia] содержит реализацию k-metoid в пакете для кластеризации JuliaStats</li>
<li>[http://research.omicsgroup.org/index.php/R_(programming_language) R] включает различные варианты k-means в пакете flexclust. Алгоритм PAM реализован в пакете cluster</li>
<li>[http://research.omicsgroup.org/index.php/MATLAB MATLAB]. Реализованы PAM, CLARA и другие алгоритмы кластеризации</li>
<li>[http://research.omicsgroup.org/index.php/Python_(programming_language) Python]. Алгоритм PAM реализован как k-medoids в пакете pyclust, содержащем также различные варианты k-means</li>
</ol>

== Литература ==
<references />
<ol>
<li>
Fasulo D. An analysis of recent work on clustering algorithms. – Technical report, 1999. – №. 01-03. – С. 02.</li>
<li>Park H. S., Jun C. H. A simple and fast algorithm for K-medoids clustering //Expert Systems with Applications. – 2009. – Т. 36. – №. 2. – С. 3336-3341.</li>
<li>Van der Laan M., Pollard K., Bryan J. A new partitioning around medoids algorithm //Journal of Statistical Computation and Simulation. – 2003. – Т. 73. – №. 8. – С. 575-584.</li>
<li>Нейский И. М. Классификация и сравнение методов кластеризации //ББК 32.813 И 76 Составитель: ЮН Филиппович. – 2006. – С. 130.</li>
</ol>

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

2016-10-15T19:51:25Z

Denemmy:

== Перенос ==
Статья: [[Кластеризация сетями Кохонена]]
Выполняют: [[Участник:Kravtsovkirill| Кравцов Кирилл]] и [[Участник:Emaksimov| Максимов Егор]]

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Partitioning Around Medoids (Алгоритм)]]
Выполняют: [[Участник:Denemmy| Галеев Данил]] и [[Участник:Ivan.Z| Запутляев Иван]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:kochet|П.А. Кочетков]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Участница:JuliaA|Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Участник:GlotovES| Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

Статья: [[Плотностный алгоритм кластеризации DBSCAN]]
Выполняют: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

Статья: [[Кластеризация Partitioning Around Medoids (PAM)]]
Выполняют:[[ Участник:Тодуа Антон| Тодуа Антон]], [[Участник:Гусева Юлия| Гусева Юлия]]

Статья: [[Участник:Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа)/Построение матрицы Адамара произвольной размерности]]
Выполняют:[[ Участник:Бугаков Юрий| Бугаков Юрий]], [[Участник:Кужамалиев Ернур| Кужамалиев Ернур]]

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T13:20:37Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T13:09:22Z

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

Файл:SWAP.png

2016-10-15T13:06:30Z

Denemmy:

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T12:36:04Z

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

Файл:BUILD.png

2016-10-15T12:31:13Z

Denemmy: Denemmy загрузил новую версию Файл:BUILD.png

Файл:BUILD.png

2016-10-15T12:15:16Z

Denemmy:

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T11:09:15Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T11:07:25Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T11:05:44Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T11:03:24Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T10:33:28Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T10:29:30Z

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

Участник:Denemmy/Partitioning Around Medoids (Алгоритм)

2016-10-15T10:03:34Z