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

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:46:32Z

Julia lukashkina: /* ЧАСТЬ. Свойства и структура алгоритмов */

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

{{Assignment}}
= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times d}</math>, число кластеров <math>= K</math>, число признаков <math>=d</math>.

На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times d}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM-ef-time.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:42:09Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math>, число кластеров <math>= K</math>.

На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM-ef-time.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:42:08Z

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

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:41:49Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math>, число кластеров <math>= K</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:40:59Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times d}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \dots, \;\mu_K</math>), матриц ковариаций (<math>\Sigma_1, \dots, \Sigma_K</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,\dots,K</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1,\dots,K</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,\dots,K</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{1K},\;g_{2K},\;g_{3K},\;\mu_K</math> — для K-ого кластера.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\dots,\;\mu_K</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\dots,\;\Sigma_K</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\dots,\;w_K</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:37:46Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3</math>, то есть 3 входных объекта.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T15:36:09Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; d = 2,\; k = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM M step2.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Файл:EM M step2.png

2016-11-16T15:34:34Z

Julia lukashkina:

Файл:EM E step.png

2016-11-16T15:32:30Z

Julia lukashkina:

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T14:49:41Z

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

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

При увеличении числа процессоров производительность растёт. Заметим также, что с увеличением числа точек, скорость работы программы линейно увеличивается.

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 5 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T14:47:12Z

Julia lukashkina: /* Возможные способы и особенности параллельной реализации алгоритма */

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T14:46:58Z

Julia lukashkina: /* Локальность данных и вычислений */

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T14:43:36Z

Julia lukashkina: /* Выводы для классов архитектур */

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-16T14:43:20Z

Julia lukashkina: /* Динамические характеристики и эффективность реализации алгоритма */

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-12T13:22:34Z

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

{{Assignment|Algoman}}

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-11-12T13:20:16Z

Julia lukashkina: /* Схема реализации последовательного алгоритма */

{{Assignment|Algoman}}

Авторы описания: [[Участник:Мария_Готман|Готман М.Л.]], [[Участник:Julia_lukashkina|Лукашкина Ю.Н.]]

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization) <ref>Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)</ref>. В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычисленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь многомерных нормальных распределений <math>p_j(x) = N(x;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x - \mu_j) \Sigma_j^{-1} (x - \mu_j)^T\biggr) </math> с весами <math>w_j</math>: <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

На вход алгоритму подаются <math>m </math> объектов, каждый из которых имеет <math>d</math> признаков, в виде матрицы объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

На E-шаге вычисляется значение скрытых переменных <math>g_{ij}</math> по текущему приближению параметров <math>\Theta</math>.

<math>g_{ij} = \frac{w_jp_j(x_i)}{\sum_{s=1}^k w_sp_s(x_i)}</math>, что интерпретируется как вероятность принадлежности объекту <math>x_i</math> к <math>j</math>-ому кластеру.

M-шаг:

Будем максимизировать логарифм полного правдоподобия:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL = fabs(\sum_{i=1}^m LL^{iter}_i - \sum_{i=1}^m LL^{iter - 1}_i)</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам. Стоит отметить, что важно корректно организовать работу с параметрами модели (матрицами ковариаций, средними значениями и весами), чтобы не произошло ситуации гонки за ресурсами <ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref>.

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

'''Входные данные''': плотная вещественная матрица объектов-признаков <math>X \in \R^{m \times d}</math> и количество кластеров <math>k</math>, где <math>m</math> — количество объектов, <math>d</math> — количество кластеров.

'''Объём входных данных''': <math>m \times d + 1</math>.

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов математических ожиданий <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц ковариации <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

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

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи <ref>Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]</ref> используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

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

<references \>

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T17:25:28Z

Julia lukashkina: /* ЧАСТЬ. Свойства и структура алгоритмов */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

{{Assignment}}
= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 40000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье [3] авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован авторами статьи с помощью MPI библиотеки MPICH.

Авторы статьи [4] используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T17:24:58Z

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

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

2016-10-14T17:03:23Z

Julia lukashkina: /* Перенос */

== Перенос ==
Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T15:57:27Z

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

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T15:56:34Z

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

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T15:55:14Z

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

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-14T15:48:23Z

Julia lukashkina: /* Последовательная сложность алгоритма */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2)) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным, так как в начале работы алгоритма происходит инициализация начальных параметров случайным образом (с учетом положительной определенности и симметричности матрицы ковариации). Посколько алгоритм сильно чувствителен к выбору начального приближения, он не может быть детерминирован.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:

* минимальная эффективность реализации 0,00072%;
* максимальная эффективность реализации 25.5037%.

[[file:EM_Efficiency.png|thumb|center|700px|Рис. 4 Эффективность EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье [3] авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи [4] используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:19:46Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с процессором Intel(R) Core(TM) i7-5820K @ 3.30GHz, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье [3] авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи [4] используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:13:47Z

Julia lukashkina: /* Литература */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье [3] авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи [4] используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Воронцов К.В.; Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio; The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg; Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:13:19Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье [3] авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи [4] используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio, The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:12:27Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье <ref>The Parallel EM Algorithm and its Applications in
Computer Vision</ref> авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio, The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:10:30Z

Julia lukashkina: /* Литература */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье The Parallel EM Algorithm and its Applications in
Computer Vision авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio, The Parallel EM Algorithm and its Applications in Computer Vision

[4] Abhinandan Das, Mayur Datar, Ashutosh Garg Google News Personalization: Scalable Online Collaborative Filtering
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:08:41Z

Julia lukashkina: /* Литература */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье The Parallel EM Algorithm and its Applications in
Computer Vision авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[3] López-de-Teruel P. E., García J. M., Acacio, The Parallel EM Algorithm and its Applications in Computer Vision

[4]
[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T16:07:32Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn].

Также существует несколько параллельных реализаций, описанных в следующих статьях:

В статье The Parallel EM Algorithm and its Applications in
Computer Vision авторы предлагают распределить вычисление скрытых переменных для каждого объекта между процессорами и на каждой итерации производить нормализацию. M-шаг предлагается параллелить по компонентам, что требует реализации корректного взаимодействия между процессорами. Предложенный вариант распараллеливания был реализован и протестирован с помощью MPI библиотеки MPICH.

Авторы статьи используют MapReduce для распараллеливания EM-алгоритма для PLSI моделей.

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T15:38:58Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T15:38:11Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

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

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Масштабируемость алгоритма и его реализации ==
Для проведения экспериментов по масштабируемости были выбраны следующие параметры алгоритма: были зафиксированы число кластеров <math>k = 4 </math>, и, также, было зафиксировано ядро рандомизации, чтобы избавиться от случайности различного выбора начального приближения параметров. Для большей показательности результатов, условие дострочного завершения работы алгоритма в случае стабилизирования логарифма правдоподобия игнорировалось, и для каждого запуска проводилось 50 итераций EM-алгоритма.
Для экспериментов было сгенерировано 20 выборок разного размера: от 10000 объектов до 200000 с шагом в 10000. Для каждой выборки время работы алгоритма усреднялось по нескольким запускам, чтобы избежать выбросов.

Для работы с многопоточностью использовалась библиотека OpenMP. С помощью нее были распараллелены основные циклы по объектам на E и M шаге.

Эксперименты проводились на компьютере с Intel(R) Core(TM) i7-5820K @ 3.30GHz процессором, который поддерживает до 12ти потоков.

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

[[file:EM_performance.png|thumb|center|700px|Рис. 4 Время работы EM алгоритма в зависимости от числа процессов и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T14:57:21Z

Julia lukashkina: /* Ресурс параллелизма алгоритма */

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-13T14:54:18Z

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

Участник:Julia lukashkina

2016-10-12T20:31:50Z

Julia lukashkina: Новая страница: «Студентка 617 группы ВМК МГУ.»

Студентка 617 группы ВМК МГУ.

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T20:11:30Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

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

Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T20:05:01Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

Алгоритм не является детерминированным (в данной реализации). Здесь предполагается, что инициализация начальных параметров не относится к вычислительной части алгоритма.
Причиной недетерминированности являются ошибки округления, которые могут менятся от запуска к запуску. Однако, эти ошибки незначительно влияют на результат работы алгоритма.

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T20:00:51Z

Julia lukashkina: /* Общее описание алгоритма */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 5ти кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T20:00:10Z

Julia lukashkina: /* Возможные способы и особенности параллельной реализации алгоритма */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T19:59:35Z

Julia lukashkina: /* Динамические характеристики и эффективность реализации алгоритма */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T19:59:03Z

Julia lukashkina: /* Выводы для классов архитектур */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T19:56:49Z

Julia lukashkina: /* Локальность данных и вычислений */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>k = 2</math>.
На шаге <math>\mathbf{init}</math> происходит инициализация начальных приближений параметров модели и затем итеративное повторение <math>\mathbf{E}</math> и <math>\mathbf{M}</math> шагов алгоритма.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]

E-шаг. На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>), матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>) и весов <math>w</math>.

Вершинами <math>\mathbf{eI}</math> обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы <math>\mathbf{eS}</math> обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа <math>\mathbf{eE}</math> обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам <math>\mathbf{eN}</math>, которые обозначают нормировку, затем в <math>\mathbf{eL}</math> происходит подсчет логарифма правдоподобия. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>\mathbf{m}\boldsymbol{\mu}</math> обозначает подсчет слагаемого математического ожидания для одного объекта, затем на шаге <math>\mathbf{mS_1}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_1}</math> нормировка математического ожидания, выходом являются <math>\mu_1,\;\mu_2</math>.
Вершина <math>\mathbf{m}\boldsymbol{\Sigma}</math> обозначает подсчет слагаемого матрицы ковариации для одного объекта, затем на шаге <math>\mathbf{mS_2}</math> происходит суммирование слагаемых, и, наконец, на шаге <math>\mathbf{mN_2}</math> нормировка матрицы ковариации, выходом являются <math>\Sigma_1,\;\Sigma_2</math>.
Операция <math>\mathbf{mS_3}</math> обозначает вычисление ненормированного веса для одного шага, затем при выполнении <math>\mathbf{mN_3}</math> происходит нормировка весов, выходом являются <math>w_1,\;w_2</math>.

[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
В данном разделе приведем код реализации последовательного алгоритма.

<source lang="c++">
double_vector em_algo::expectation_step(double_matrix& features)
{
long n_objects = features.size1();
int n_clusters = parameters.sigmas.size();
double pi = boost::math::constants::pi<double>();

// precalculate inverse matrices and dets
std::vector<double_matrix> sigmas_inverted(n_clusters);
std::vector<double> norm_distribution_denominator(n_clusters);
for (int i = 0; i < n_clusters; ++i)
{
double_matrix sigma_inverted(parameters.sigmas[i].size1(), parameters.sigmas[i].size2());
double det = InvertMatrix(parameters.sigmas[i], sigma_inverted);
if (det == 0)
{
std::cerr << "Matrix can not be inverted\n";
exit(1);
}
norm_distribution_denominator[i] = sqrt(pow(2 * pi, parameters.n_features) * det);
sigmas_inverted[i] = sigma_inverted;
}

hidden_vars = double_matrix(n_objects, n_clusters);
double_vector log_likelihood(n_objects, 0);

for (auto i = 0; i < n_objects; ++i)
{
double_matrix_row x(features, i);
double norm_value = 0;
for (auto j = 0; j < n_clusters; ++j)
{
double_matrix_column current_means(parameters.means, j);
double_vector x_centered = x - current_means;

double exp_power = -0.5 * inner_prod(prod(x_centered, sigmas_inverted[j]), x_centered);
hidden_vars(i, j) = parameters.weights(j) * exp(exp_power) / norm_distribution_denominator[j];

norm_value += hidden_vars(i, j);
}
double_matrix_row hidden_vars_row(hidden_vars, i);
if (norm_value != 0)
{
hidden_vars_row = hidden_vars_row / norm_value;
log_likelihood(i) = log(inner_prod(hidden_vars_row, parameters.weights));
}

}
return log_likelihood;
}

void em_algo::maximization_step(double_matrix& features)
{
int n_objects = features.size1();

double_vector w = double_vector(n_clusters, 0.0);
double_matrix means = double_matrix(parameters.n_features, n_clusters, 0.0);
std::vector<double_matrix> sigmas;
for (int j = 0; j < n_clusters; ++j)
sigmas.push_back(double_matrix(parameters.n_features, parameters.n_features, 0.0));

for (int i = 0; i < n_objects; ++i)
{
double_matrix_row x_i = row(features, i);

for (int j = 0; j < n_clusters; ++j)
{
double g = hidden_vars(i, j);
w(j) += g;

double_matrix_column single_mean = column(means, j);

single_mean += g * x_i;

double_vector x_centered = x_i - column(parameters.means, j);
for (int k = 0; k < parameters.n_features; ++k)
for (int l = 0; l < parameters.n_features; ++l)
sigmas[j](k, l) = sigmas[j](k, l) + g * x_centered(k) * x_centered(l);
}
}
// update weights
parameters.weights = w / n_objects;

for (int j = 0; j < n_clusters; ++j) {
double weight = w(j);
// update means
double_matrix_column means_old = column(parameters.means, j);
double_matrix_column means_new = column(means, j);
means_old = means_new / weight;

// update sigmas
parameters.sigmas[j] = sigmas[j] / weight;
for (int k = 0; k < parameters.n_features; ++k)
parameters.sigmas[j](k, k) = parameters.sigmas[j](k, k) + tol;
}
}

bool em_algo::is_likelihood_stabilized(double_vector likelihood, double_vector previous_likelihood)
{
double likelihood_diff = sum(likelihood) - sum(previous_likelihood);
return fabs(likelihood_diff) < tol;
}

model em_algo::process(double_matrix& features, int max_iterations)
{
int iteration = 0;
double_vector likelihood, previous_likelihood;
while (iteration++ < max_iterations && (iteration <= 2 || !is_likelihood_stabilized(likelihood, previous_likelihood)))
{
previous_likelihood = likelihood;
likelihood = expectation_step(features);
maximization_step(features);
}
return parameters;
}
</source>

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

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T13:32:50Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>= 2</math>. Происходит инициализация начальных приближений параметров модели и затем итеративное повторение E и M шагов алгоритма.

'''E-шаг.''' На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>) и матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>).

Вершинами ''eI'' обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы ''eS'' обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа ''eE'' обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам ''eN'', которые обозначают нормировку. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]
[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина <math>]\textbf{m\mu}</math>
[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T13:31:00Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>= 2</math>. Происходит инициализация начальных приближений параметров модели и затем итеративное повторение E и M шагов алгоритма.

'''E-шаг.''' На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>) и матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>).

Вершинами ''eI'' обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы ''eS'' обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа ''eE'' обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам ''eN'', которые обозначают нормировку. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 — структура E-шага и на рис.3 — структура M-шага.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]
[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> — для второго.

Вершина m<math>\mu</math>
[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T13:28:35Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>= 2</math>. Происходит инициализация начальных приближений параметров модели и затем итеративное повторение E и M шагов алгоритма.

'''E-шаг.''' На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>) и матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>).

Вершинами ''eI'' обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы ''eS'' обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа ''eE'' обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам ''eN'', которые обозначают нормировку. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 - структура E-шага и на рис.3 - структура M-шага.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]
[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]

M-шаг. На рисунке 3 изображена схема M-шага.
Входными параметрами являются: исходные объекты <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math>, скрытые переменные <math>g_{11},\;g_{21},\;g_{31},\;\mu_1</math> для пересчета параметров первого кластера и <math>g_{12},\;g_{22},\;g_{32},\;\mu_2</math> - для второго.
[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T13:16:39Z

Julia lukashkina: /* Ресурс параллелизма алгоритма */

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>= 2</math>. Происходит инициализация начальных приближений параметров модели и затем итеративное повторение E и M шагов алгоритма.

'''E-шаг.''' На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>) и матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>).

Вершинами ''eI'' обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы ''eS'' обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа ''eE'' обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам ''eN'', которые обозначают нормировку. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 - структура E-шага и на рис.3 - структура M-шага.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]
[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]
[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

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

В данной статье рассматривается вариант распараллеливания по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-09T13:05:00Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>\tilde w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\tilde \mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\tilde \Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w_j = \frac{\tilde w_j}{m}</math>, <math>\mu_j = \frac{\tilde \mu_j}{w_j}, \tilde \Sigma_j = \frac{\tilde \Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

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

Опишем граф алгоритма для следующих входных данных: <math>m = 3,\; k = 2,\; d = 2</math>, то есть 3 входных объекта и 2 кластера.

На рис.1 показана макроструктура EM-алгоритма. Входными данными в таком случае являются матрица <math>X \in \R^{3 \times 2}</math> и число кластеров <math>= 2</math>. Происходит инициализация начальных приближений параметров модели и затем итеративное повторение E и M шагов алгоритма.

'''E-шаг.''' На рис.2 детально изображена схема E-шага.
Входные параметры <math>x_1,\; x_2,\; x_3 \in \R^{1 \times 2}</math> являются строчками входной матрицы <math>X</math>, также на вход подаются текущие приближения векторов средних значений (<math>\mu_1, \;\mu_2</math>) и матриц ковариаций (<math>\Sigma_1, \Sigma_2</math>).

Вершинами ''eI'' обозначена операция нахождения обратной матрицы <math>\Sigma_j^{-1},\; j = 1,2</math>. Вершины группы ''eS'' обозначают вычитание векторов <math>x_i - \mu_j,\; i = 1,2,3; \; j = 1, 2</math>. Салатовые узлы графа ''eE'' обозначают вычисление ненормированного значения <math>g_{ij}, \;i = 1,2,3;\;j=1,2</math> по формулам из раздела [[#Схема реализации последовательного алгоритма|описания алгоритма]]. Далее выход вершин этой группы подаётся на вход вершинам ''eN'', которые обозначают нормировку. На выходе этого графа получаются скрытые переменные <math>g_{ij}</math> и логарифм правдоподобия LL.

На рис.1 показана структура ЕM-алгоритма для кластеризации, на рис.2 - структура E-шага и на рис.3 - структура M-шага.

[[file:EM.png|thumb|center|300px|Рис.1. Граф EM-алгоритма с отображением входных и выходных данных]]
[[file:EM_E_step.png|thumb|center|500px|Рис.2. Граф E-шага с отображением входных и выходных данных]]
[[file:EM_M_step.png|thumb|center|500px|Рис.3. Граф M-шага с отображением входных и выходных данных]]

== Ресурс параллелизма алгоритма ==
Эм, ну по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Математические методы обучения по прецедентам (теория обучения машин)

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-08T17:27:01Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j) \Sigma_j^{-1} (x_i - \mu_j)^T\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)(x_i - \mu_j)^T,\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
M-шаг:
# вычисление <math>w_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(m)</math>, для весов всех кластеров — <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(dm)</math>, для всех кластеров — <math>O(dmk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> при фиксированном <math>j</math> имеет сложность <math>O(d^2m)</math>, для всех кластеров — <math>O(d^2mk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> имеет сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(d^2k)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> имеет сложность <math>O(1)</math>

Сложность алгоритма на одной итерации:

<math>O(k(d^2+dm+m+m+dm+d^2m+1+d+d^2) = O(d^2mk)</math>, так как мы рассматриваем задачу для двумерного случая, то есть <math>d=2</math>, множитель <math>d^2</math> можно отнести в константу, итоговая сложность вычисления на одной итерации <math>O(mk)</math>.

Для <math>n</math> итераций итоговая сложность алгоритма будет равна:

<math>O(mkn)</math>, где <math>m</math> — число объектов, <math>k</math> — число кластеров, <math>n</math> — число итераций.

== Информационный граф ==
Это очень важный раздел описания. Именно здесь можно показать (увидеть) как устроена параллельная структура алгоритма, для чего приводится описание и изображение его информационного графа ([[глоссарий#Граф алгоритма|''графа алгоритма'']] [1]). Для рисунков с изображением графа будут составлены рекомендации по их формированию, чтобы все информационные графы, внесенные в энциклопедию, можно было бы воспринимать и интерпретировать одинаково. Дополнительно можно привести полное параметрическое описание графа в терминах покрывающих функций [1].

Интересных вариантов для отражения информационной структуры алгоритмов много. Для каких-то алгоритмов нужно показать максимально подробную структуру, а иногда важнее макроструктура. Много информации несут разного рода проекции информационного графа, выделяя его регулярные составляющие и одновременно скрывая несущественные детали. Иногда оказывается полезным показать последовательность в изменении графа при изменении значений внешних переменных (например, размеров матриц): мы часто ожидаем "подобное" изменение информационного графа, но это изменение не всегда очевидно на практике.

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

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

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

На рис.1 показана информационная структура алгоритма умножения матриц, на рис.2 - информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей.

[[file:Fig1.svg|thumb|center|300px|Рис.1. Информационная структура алгоритма умножения матриц]]
[[file:Fig2.svg|thumb|center|300px|Рис.2. Информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей]]

== Ресурс параллелизма алгоритма ==
Эм, ну по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Соотношение последовательной и параллельной сложности являются константой(<math>O(mkn)</math> к <math>O(mkn)</math>).

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: opencv [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Лекции по статистическим (байесовским) алгоритмам классификации

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-08T16:58:16Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j)^T \Sigma_j^{-1} (x_i - \mu_j)\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление обратной матрицы <math>\Sigma_j^{-1}, j = 1 : k</math> при фиксированном <math>j</math> для двумерного случая по явным формулам имеет сложность <math>O(d^2)</math>, для всех кластеров — <math>O(d^2k)</math>
# вычисление <math>g_{ij}, i = 1 : m, j = 1 : k</math> при фиксированных <math>i, j</math> имеет сложность <math>O(d)</math>, сложность вычисления матрицы G — <math>O(dmk)</math>
# вычисление <math>LL_i, i = 1 : m</math> при фиксированном <math>i</math> имеет сложность <math>O(k)</math>, для всех объектов имеет сложность <math>O(mk)</math>,
[M-шаг]
# вычисление <math>w_j, j = 1 : k</math> — <math>O(m)</math>, для весов всех кластеров сложность <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> сложность <math>O(dnk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> сложность <math>O(dnk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(dk^2)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> <math>O(1)</math>

== Информационный граф ==
Это очень важный раздел описания. Именно здесь можно показать (увидеть) как устроена параллельная структура алгоритма, для чего приводится описание и изображение его информационного графа ([[глоссарий#Граф алгоритма|''графа алгоритма'']] [1]). Для рисунков с изображением графа будут составлены рекомендации по их формированию, чтобы все информационные графы, внесенные в энциклопедию, можно было бы воспринимать и интерпретировать одинаково. Дополнительно можно привести полное параметрическое описание графа в терминах покрывающих функций [1].

Интересных вариантов для отражения информационной структуры алгоритмов много. Для каких-то алгоритмов нужно показать максимально подробную структуру, а иногда важнее макроструктура. Много информации несут разного рода проекции информационного графа, выделяя его регулярные составляющие и одновременно скрывая несущественные детали. Иногда оказывается полезным показать последовательность в изменении графа при изменении значений внешних переменных (например, размеров матриц): мы часто ожидаем "подобное" изменение информационного графа, но это изменение не всегда очевидно на практике.

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

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

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

На рис.1 показана информационная структура алгоритма умножения матриц, на рис.2 - информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей.

[[file:Fig1.svg|thumb|center|300px|Рис.1. Информационная структура алгоритма умножения матриц]]
[[file:Fig2.svg|thumb|center|300px|Рис.2. Информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей]]

== Ресурс параллелизма алгоритма ==
Эм, ну по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Весьма полезным является ''соотношение последовательной и параллельной сложности'' алгоритма. Оба понятия мы рассматривали ранее, но здесь делается акцент на том выигрыше, который теоретически может дать параллельная реализация алгоритма. Не менее важно описать и те сложности, которые могут возникнуть в процессе получения параллельной версии алгоритма.

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

Алгоритм сбалансирован по E и M шагам, затраты на выполнение этих этапов примерно одинаковы.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: opencv [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Лекции по статистическим (байесовским) алгоритмам классификации

[[en:Description of algorithm properties and structure]]

Участник:Мария Готман/Алгоритм кластеризации, основанный на максимизации ожидания

2016-10-08T16:54:47Z

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

Авторы описания: Готман М.Л., Лукашкина Ю.Н.

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Задача кластеризации — это задача разбиения заданной входной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались.

Для решения этой задачи можно использовать, например, метод максимизации ожидания, также известный как EM-алгоритм (англ. expectation-maximization). В таком случае делается предположение, что входные данные — смесь многомерных нормальных распределений, соотвественно отдельный кластер — это одна компонента смеси. Предполагается, что количество кластеров является входным параметром алгоритма (существуют модификации EM-алгоритма, которые автоматически находят число кластеров, но они не рассматриваются в данной статье). Результат работы EM-алгоритма — веса кластеров и найденные параметры нормальных распределений для каждого кластера: вектора математических ожиданий и матрицы ковариации.

Алгоритм EM кластеризации основан на итеративном выполнении двух последовательных шагов: E-шага и M-шага. На E-шаге вычисляеются вспомогательные (скрытые) переменные, которые характеризуют апостериорную вероятность того, что определенный обучающий объект получен из фиксированной компоненты смеси. На M-шаге с помощью вычесленных скрытых переменных производится обновление параметров смеси: по определённым формулам пересчитываются веса кластеров, их математические ожидания и матрицы ковариаций.

Стоит отметить, что на работу EM-алгоритма значительно влияет начальное приближение его параметров. При неудачной инициализации алгоритм может не сойтись или сойтись в локальный экстремум.

В данной статье рассматривается частный случай EM-алгоритма, который работает с двумерными входными данными.

[[Файл:Em clusters 4.png|400px|thumb|center|Пример работы EM-алгоритма для 4х кластеров.]]

== Математическое описание алгоритма ==
Рассматривается смесь нормальных распределений <math>p(x)=\sum_{j=1}^kw_jp_j(x), \sum_{j=1}^kw_j =1, w_j \ge 0</math>.

Алгоритм кластеризации, основанный на максимизации правдоподобия, итеративно выполняет два шага: E-шаг и M-шаг.
Идея алгоритма заключается в введении матрицы скрытых переменных <math>G</math>, где <math>g_{ij} \equiv P(\theta_j |x_i)</math> обозначает вероятность принадлежности <math>i</math>-го объекта <math>j</math>-му кластеру.

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

На вход алгоритму подается матрица объектов-признаков <math>X \in \R^{m \times d}</math> и <math>k</math> — количество кластеров.

На выходе получаем набор параметров модели для каждого кластера <math>\Theta = (w_1,...,w_k;\;\mu_1,...,\mu_k;\;\Sigma_1,...,\Sigma_k)</math>, где <math>w_j</math> — вес <math>j</math>-го кластера в смеси нормальных распределений, <math>\mu_j</math> — математическое ожидание <math>j</math>-ой компоненты смеси, <math>\Sigma_j</math> — матрица ковариации <math>j</math>-ой компоненты смеси.

E-шаг:

<math>g_{ij} = \frac{w_jN(x_i;\mu_j, \Sigma_j)}{\sum_{s=1}^k w_sN(x_i;\mu_s, \Sigma_s)}</math>

M-шаг:

<math>Q(\Theta) = \ln\prod_{i=1}^mp(x_i) = \sum_{i=1}^m\ln\sum_{j=1}^kw_jp_j(x_i) \rightarrow \max_{\Theta}</math>, при условии <math>\sum_{j=1}^kw_j=1</math>, где

<math>p_j(x_i) = N(x_i;\mu_j, \Sigma_j) = \frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}} \exp \biggl(-\frac{1}{2}(x_i - \mu_j)^T \Sigma_j^{-1} (x_i - \mu_j)\biggr) </math>

Решением оптимизационной задачи являются формулы для пересчета параметров:

<math>w_j = \frac1m\sum_{i=1}^m g_{ij}</math>,

<math>\mu_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}x_i</math>,

<math>\Sigma_j = \frac1{mw_j}\sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1, \dots, k</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное вычисление всех параметров модели, независимое по <math>m</math> объектам выборки <math>X</math>.
На каждой итерации алгоритма на Е-шаге пересчитывается значение скрытых переменных, на M-шаге пересчет параметров модели с учетом скрытых переменных.

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вычисления элементов матрицы G на E шаге, и пересчет параметров <math>\Theta</math> на M-шаге.

== Схема реализации последовательного алгоритма ==
# Инициализация параметров
# for iter = 1 : max_iterations
# [E-шаг]
## вычисление <math>\Sigma_j^{-1}</math> и <math>\frac1{(2\pi)^{d/2}\sqrt{|\Sigma_j|}}, j = 1 : k</math>
## вычисление <math>g_{ij},\;i = 1 : m, \; j = 1 : k</math>
## вычисление <math>LL_i</math> (логарифм правдоподобия), <math>\;i = 1 : m</math>
# [M-шаг]
## вычисление <math>w_j = \sum_{i=1}^m g_{ij}, \; j = 1 : m</math>
## вычисление <math>\mu_j = \sum_{i=1}^m g_{ij}x_i,\; j = 1 : k</math>
## вычисление <math>\Sigma_j = \sum_{i=1}^m g_{ij}(x_i - \mu_j)^T(x_i - \mu_j),\; j = 1 : k</math>
## нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, \;j = 1 : k</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math>
# if (<math>\Delta LL < \varepsilon</math>) then break;
# end for

== Последовательная сложность алгоритма ==
E-шаг:
# вычисление <math>\Sigma_j^{-1}</math> для двумерного случая по явным формулам сложность <math>O(d^2)</math>
# вычисление <math>g_{ij}, i = 1 : m, \; j = 1 : k</math> сложность <math>O(nk)</math>
# вычисление <math>LL_i</math> сложность <math>O(nk)</math>
[M-шаг]
# вычисление <math>w_j, j = 1 : k</math> — <math>O(m)</math>, для весов всех кластеров сложность <math>O(mk)</math>
# вычисление <math>\mu_j, j = 1 : k</math> сложность <math>O(dnk)</math>
# вычисление <math>\Sigma_j, j = 1 : k</math> сложность <math>O(dnk)</math>
# нормировка <math>w</math>, <math>\mu_j = \frac{\mu_j}{w_j}, \Sigma_j = \frac{\Sigma_j}{w_j}, j = 1 : k</math> сложность <math>O(k)</math>, <math>O(dk)</math>, <math>O(dk^2)</math>
# вычисление изменения логарифма правдоподобия<math>\Delta LL</math> <math>O(1)</math>

== Информационный граф ==
Это очень важный раздел описания. Именно здесь можно показать (увидеть) как устроена параллельная структура алгоритма, для чего приводится описание и изображение его информационного графа ([[глоссарий#Граф алгоритма|''графа алгоритма'']] [1]). Для рисунков с изображением графа будут составлены рекомендации по их формированию, чтобы все информационные графы, внесенные в энциклопедию, можно было бы воспринимать и интерпретировать одинаково. Дополнительно можно привести полное параметрическое описание графа в терминах покрывающих функций [1].

Интересных вариантов для отражения информационной структуры алгоритмов много. Для каких-то алгоритмов нужно показать максимально подробную структуру, а иногда важнее макроструктура. Много информации несут разного рода проекции информационного графа, выделяя его регулярные составляющие и одновременно скрывая несущественные детали. Иногда оказывается полезным показать последовательность в изменении графа при изменении значений внешних переменных (например, размеров матриц): мы часто ожидаем "подобное" изменение информационного графа, но это изменение не всегда очевидно на практике.

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

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

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

На рис.1 показана информационная структура алгоритма умножения матриц, на рис.2 - информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей.

[[file:Fig1.svg|thumb|center|300px|Рис.1. Информационная структура алгоритма умножения матриц]]
[[file:Fig2.svg|thumb|center|300px|Рис.2. Информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей]]

== Ресурс параллелизма алгоритма ==
Эм, ну по объектам.

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

'''Входные данные''': плотная вещественная матрица объекты-признаки <math>X \in \R^{m \times d}</math>, количество кластеров <math>k</math>

'''Объём входных данных''': <math>m \times d + 1</math>

'''Выходные данные''': вектор весов <math>w \in \R^{k \times 1}</math>, <math>\;\;k</math> векторов <math>\mu_j \in \R^{d \times 1}</math>, <math>\;\;k</math> матриц <math>\Sigma \in \R^{d \times d}</math>

'''Объём выходных данных''': <math>k \times (d \times d + d + 1)</math>

Стоит заметить, что модель смеси распеределения полностью восстанавливается по выходным данным, и задача предсказания метки кластера для входных объектов является тривиальной.

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

Весьма полезным является ''соотношение последовательной и параллельной сложности'' алгоритма. Оба понятия мы рассматривали ранее, но здесь делается акцент на том выигрыше, который теоретически может дать параллельная реализация алгоритма. Не менее важно описать и те сложности, которые могут возникнуть в процессе получения параллельной версии алгоритма.

[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна отношению числа операций к суммарному объему входных и выходных данных. Она показывает, сколько операций приходится на единицу переданных данных. Несмотря на простоту данного понятия, это значение исключительно полезно на практике: чем выше вычислительная мощность, тем меньше накладных расходов вызывает перемещение данных для их обработки, например, на сопроцессоре, ускорителе или другом узле кластера. Например, вычислительная мощность скалярного произведения двух векторов равна всего лишь <math>1</math>, а вычислительная мощность алгоритма умножения двух квадратных матриц равна <math>2n/3</math>.

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

''Сбалансированность'' вычислительного процесса можно рассматривать с разных сторон. Здесь и сбалансированность типов операций, в частности, арифметических операций между собой (сложение, умножение, деление) или же арифметических операций по отношению к операциям обращения к памяти (чтение/запись). Здесь и сбалансированность операций между параллельными ветвями алгоритма. С одной стороны, балансировка нагрузки является необходимым условием эффективной реализации алгоритма. Вместе с этим, это очень непростая задача, и в описании должно быть отмечено явно, насколько алгоритм обладает этой особенностью. Если обеспечение сбалансированности не очевидно, желательно описать возможные пути решения этой задачи.

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

[[глоссарий#Степень исхода|''Степень исхода вершины информационного графа'']] показывает, в скольких операциях ее результат будет использоваться в качестве аргумента. Если степень исхода вершины велика, то на этапе реализации алгоритма нужно позаботиться об эффективном доступе к результату ее работы. В этом смысле, особый интерес представляют рассылки данных, когда результат выполнения одной операции используется во многих других вершинах графа, причем число таких вершин растет с увеличением значения внешних переменных.

''"Длинные" дуги в информационном графе'' [1] говорят о потенциальных сложностях с размещением данных в иерархии памяти компьютера на этапе выполнения программы. С одной стороны, длина дуги зависит от выбора конкретной системы координат, в которой расположены вершины графа, а потому в другой системе координат они попросту могут исчезнуть (но не появится ли одновременно других длинных дуг?). А с другой стороны, вне зависимости от системы координат их присутствие может быть сигналом о необходимости длительного хранения данных на определенном уровне иерархии, что накладывает дополнительные ограничения на эффективность реализации алгоритма. Одной из причин возникновения длинных дуг являются рассылки скалярных величин по всем итерациям какого-либо цикла: в таком виде длинные дуги не вызывают каких-либо серьезных проблем на практике.

Для проектирования специализированных процессоров или реализации алгоритма на ПЛИС представляют интерес ''компактные укладки информационного графа'' [1], которые также имеет смысл привести в данном разделе.

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

== Особенности реализации последовательного алгоритма ==
Здесь описываются особенности и варианты реализации алгоритма в виде последовательной программы, которые влияют на [[глоссарий#Эффективность реализации|''эффективность ее выполнения'']]. В частности, в данном разделе имеет смысл ''сказать о существовании блочных вариантов реализации алгоритма'', дополнительно описав потенциальные преимущества или недостатки, сопровождающие такую реализацию. Важный вопрос - это ''возможные варианты организации работы с данными'', варианты структур данных, наборов временных массивов и другие подобные вопросы. Для различных вариантов реализации следует оценить доступный ресурс параллелизма и объем требуемой памяти.

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

Опираясь на информацию из [[#Описание ресурса параллелизма алгоритма|п.1.8]] (описание ресурса параллелизма алгоритма), при описании последовательной версии стоит сказать про возможности [[глоссарий#Эквивалентное преобразование|''эквивалентного преобразования программ'']], реализующих данных алгоритм. В дальнейшем, это даст возможность простого использования доступного параллелизма или же просто покажет, как использовать присущий алгоритму параллелизм на практике. Например, параллелизм на уровне итераций самого внутреннего цикла обычно используется для векторизации. Однако, в некоторых случаях этот параллелизм можно поднять "вверх" по структуре вложенности объемлющих циклов, что делает возможной и эффективную реализацию данного алгоритма на многоядерных SMP-компьютерах.

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

== [[Локальность данных и вычислений]] ==
Вопросы локальности данных и вычислений не часто изучаются на практике, но именно локальность определяет эффективность выполнения программ на современных вычислительных платформах [2, 3]. В данном разделе приводятся оценки степени [[глоссарий#Локальность использования данных|''локальности данных'']] и [[глоссарий#Локальность вычислений|вычислений]] в программе, причем рассматривается как [[глоссарий#Временная локальность|''временна́я'']], так и [[глоссарий#Пространственная локальность|''пространственная'']] локальность. Отмечаются позитивные и негативные факты, связанные с локальностью, какие ситуации и при каких условиях могут возникать. Исследуется, как меняется локальность при переходе от последовательной реализации к параллельной. Выделяются ключевые шаблоны взаимодействия программы, реализующей описываемый алгоритм, с памятью. Отмечается возможная взаимосвязь между используемыми конструкциями языков программирования и степенью локальности, которыми обладают результирующие программы.

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

На рис.3 и рис.4 показаны профили обращения в память для программ, реализующих разложение Холецкого и быстрое преобразование Фурье, по которым хорошо видна разница свойств локальности у данных алгоритмов.

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рис.3 Реализация метода Холецкого. Общий профиль обращений в память]]
[[file:fft 1.PNG|thumb|center|700px|Рис.4 Нерекурсивная реализация БПФ для степеней двойки. Общий профиль обращений в память]]

== Возможные способы и особенности параллельной реализации алгоритма ==
Раздел довольно обширный, в котором должны быть описаны основные факты и положения, формирующие параллельную программу. К их числу можно отнести:
* представленный иерархически ресурс параллелизма, опирающийся на структуру циклических конструкций и на граф вызовов программы;
* комбинацию (иерархию) массового параллелизма и параллелизма конечного;
* возможные способы распределения операций между процессами/нитями;
* возможные способы распределения данных;
* оценку количества операций, объёма и числа пересылок данных (как общего числа, так и в пересчёте на каждый параллельный процесс);

и другие.

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==
Это объемный раздел AlgoWiki, поскольку оценка эффективности реализации алгоритма требует комплексного подхода [5], предполагающего аккуратный анализ всех этапов от архитектуры компьютера до самого алгоритма. Основная задача данного раздела заключается в том, чтобы оценить степень эффективности параллельных программ, реализующих данный алгоритм на различных платформах, в зависимости от числа процессоров и размера задачи. Эффективность в данном разделе понимается широко: это и [[глоссарий#Эффективность распараллеливания|''эффективность распараллеливания'']] программы, это и [[глоссарий#Эффективность реализации|''эффективность реализации'']] программ по отношению к пиковым показателям работы вычислительных систем.

Помимо собственно показателей эффективности, нужно описать и все основные причины, из-за которых эффективность работы параллельной программы на конкретной вычислительной платформе не удается сделать выше. Это не самая простая задача, поскольку на данный момент нет общепринятой методики и соответствующего инструментария, с помощью которых подобный анализ можно было бы провести. Требуется оценить и описать эффективность работы с памятью (особенности профиля взаимодействия программы с памятью), эффективность использования заложенного в алгоритм ресурса параллелизма, эффективность использования коммуникационной сети (особенности коммуникационного профиля), эффективность операций ввода/вывода и т.п. Иногда достаточно интегральных характеристик по работе программы, в некоторых случаях полезно показать данные мониторинга нижнего уровня, например, по загрузке процессора, кэш-промахам, интенсивности использования сети Infiniband и т.п. Хорошее представление о работе параллельной MPI-программы дают данные трассировки, полученные, например, с помощью системы Scalasca.

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

На практике это сделать можно по-разному: либо все свести в один текущий раздел, либо же соответствующие факты сразу включать в предшествующие разделы, где они обсуждаются и необходимы по смыслу. В некоторых случаях, имеет смысл делать отдельные варианты всей [[#ЧАСТЬ. Программная реализация алгоритмов|части II]] AlgoWiki применительно к отдельным классам архитектур, оставляя общей машинно-независимую [[#ЧАСТЬ. Свойства и структура алгоритмов|часть I]]. В любом случае, важно указать и позитивные, и негативные факты по отношению к конкретным классам. Можно говорить о возможных вариантах оптимизации или даже о "трюках" в написании программ, ориентированных на целевые классы архитектур.

== Существующие реализации алгоритма ==
Существуют следующие последовательные реализации EM-алгоритма для кластеризации: opencv [http://docs.opencv.org/2.4/modules/ml/doc/expectation_maximization.html# opencv], [http://scikit-learn.org/stable/modules/mixture.html scikit-learn]

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] К.В.Воронцов. Лекции по статистическим (байесовским) алгоритмам классификации

[[en:Description of algorithm properties and structure]]