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

Алгоритм Беллмана-Форда

2017-01-25T12:04:16Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(mn)</math> против <math>O(m + n\ln n)</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>n-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>n</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>n-1</math> итерацию, на каждой из которых происходит релаксация <math>m</math> рёбер. Таким образом, общий объём работы составляет <math>O(mn)</math> операций.

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

# Если на очередной итерации не произошло ни одной успешной релаксации, то алгоритм завершает работу.
# На очередной итерации рассматриваются не все рёбра, а только выходящие из вершин, для которых на прошлой итерации была выполнена успешная релаксация (на первой итерации – только рёбра, выходящие из источника).

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. На приведенном далее информационном графе нижний уровень параллелизма обозначен в горизонтальных плоскостях. Множество всех плоскостей представляет собой верхний уровень параллелизма (операции в каждой плоскости могут выполняться параллельно).

Нижний уровень параллелизма на графе алгоритма расположен на уровнях {2 и 3}, соответствующим операциям инициализации массива дистанций (2) и обновления массива c использованием данных массива ребер {3}. Операция {4} - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

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

При использовании атомарных операций для вычисления минимума релаксация рёбер может производится параллельно. В этом случае потребуется <math>O(n)</math> шагов при использовании <math>O(m)</math> процессоров.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

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

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

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

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(m)</math>.

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

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации алгоритма Беллмана-Форда. Первое, что сразу стоит отметить – число обращений в память гораздо больше числа задействованных данных. Это говорит о частом повторном использовании одних и тех же данных, что обычно приводит к высокой временной локальности. Далее, видна явная регулярная структура производимых обращений в память, видны повторяющиеся итерации работы алгоритма. Практически все обращения образуют фрагменты, похожие на последовательный перебор, кроме самой верхней части, где наблюдается более сложная структура.

Рассмотрим более детально отдельные фрагменты общего профиля, чтобы лучше разобраться в его структуре. На рис. 3 представлен фрагмент 1 (выделен на рис. 2), на котором показаны первые 500 обращений в память (отметим, что другой наклон двух последовательных переборов связан с измененным отношением сторон в рассматриваемой области). Данный рисунок показывает, что выделенные желтым части 1 и 2 являются практические идентичными последовательными переборами; отличие между ними только в том, что в части 1 обращения выполняются в два раза чаще, поэтому на рис. 3 эта часть представлена большим числом точек. Как мы знаем, подобные профили характеризуются высокой пространственной и низкой временной локальностью.

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

Далее рассмотрим более интересный фрагмент 2, отмеченный на рис. 2 (см. рис. 4). Здесь можно снова увидеть подтверждение регулярности обращений в нижней области профиля, однако верхняя область явно устроена гораздо сложнее; хотя и здесь просматривается регулярность. В частности, также видны те же самые итерации, в которых здесь можно выделить большие последовательности обращений к одним и тем же данным. Пример такого поведения, оптимального с точки зрения локальности, выделен на рисунке желтым.

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

Чтобы понять структуру обращений в память в верхней части, можно рассмотреть ее еще подробнее. Приведем визуализацию небольшой области фрагмента 1, выделенную на рис. 4 зеленым. Однако в данном случае дальнейшее приближение (рис. 5) не привносит большей ясности: видна нерегулярная структура внутри итерации, характер которой достаточно сложно описать. Но в данном случае этого и не требуется – можно заметить, что по вертикали отложено всего 15 элементов, при этом обращений к ним выполняется гораздо больше. Независимо от структуры обращений, такой профиль обладает очень высокой как пространственной, так и временной локальностью.

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 1]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:APSP scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 5%. Это достаточно неэффективная картина даже для программ, запущенных c использованием одного ядра в реализации.

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 140 млн/сек это очень высокий показатель, показывающие потенциальную причину неэффективности.

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных в пакетах в секунду наблюдается аналогичная картина очень высокой интенсивности на первом этапе выполнения задачи. Далее сеть почти не используется.

В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала стабильно интенсивно, однако очень неэффективно использовала память из-за очень большого размера графа.

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

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).

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

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-01-20T23:16:47Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Борувки'''<ref>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref><ref>Jarník, Vojtěch. “O Jistém Problému Minimálním (Z Dopisu Panu O. Borůvkovi).” Práce Moravské Přírodovědecké Společnosti 6, no. 4 (1930): 57–63.</ref> предназначен для решения [[Построение минимального остовного дерева (MST)|задачи о построении минимального остовного дерева]] во взвешенном неориентированном графе. Алгоритм хорошо параллелизуется и является основой для распределённого [[Алгоритм GHS|алгоритма GHS]].

=== Математическое описание алгоритма ===

Пусть задан связный неориентированный граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math>. Предполагается, что веса всех рёбер различны (если это не так, то можно упорядочить рёбра сначала по весу, а потом по номеру).

Алгоритм Борувки основан на следующих двух свойствах задачи:
* '''Минимальное ребро фрагмента'''. Пусть <math>F</math> – фрагмент минимального остовного дерева и <math>e_F</math> – ребро наименьшего веса, исходящее из <math>F</math> (т.е. ровно один его конец является вершиной из <math>F</math>). Если ребро <math>e_F</math> единственно, то оно принадлежит минимальному остовному дереву.
* '''Схлопывание фрагментов'''. Пусть <math>F</math> – фрагмент минимального остовного дерева графа <math>G</math>, а граф <math>G'</math> получен из <math>G</math> склеиванием вершин, принадлежащих <math>F</math>. Тогда объединение <math>F</math> и минимального остовного дерева графа <math>G'</math> даёт минимальное остовное дерево исходного графа <math>G</math>.

В начале работы алгоритма каждая вершина графа <math>G</math> является отдельным фрагментом. На очередном шаге у каждого фрагмента выбирается исходящее ребро минимального веса (если такое ребро существует). Выбранные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты склеиваются.

=== Вычислительное ядро алгоритма ===
Основными операциями являются:
# Поиск минимального по весу исходящего ребра в каждом фрагменте.
# Объединение фрагментов.

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

Классический пример (из статьи Борувки) – спроектировать наиболее дешёвую электрическую сеть, зная стоимость устройства каждого участка электрической линии.

Пусть задан связный граф <math>G=(V,E)</math> с вершинами <math>V = ( v_{1}, v_{2}, ..., v_{n} )</math> и рёбрами <math>E = ( e_{1}, e_{2}, ..., e_{m} )</math>. Каждому ребру <math>e \in E</math> приписан вес <math>w(e)</math>.

Требуется построить дерево <math>T^* \subseteq E</math>, связывающее все вершины, и имеющее наименьший возможный вес среди всех таких деревьев:

<math> w(T^* )= \min_T( w(T)) </math>

где вес множества рёбер есть сумма их весов:

<math>w(T)=\sum_{e \in T} (w(T))</math>

Если граф <math>G</math> не является связным, то дерева, связывающего все вершины, не существует.

В этом случае необходимо найти минимальной остовное дерево для каждой компоненты связности <math>G</math>. Набор таких деревьев называется минимальным остовным лесом (сокращённо MSF – Minimum Spanning Forest).

==== Вспомогательный алгоритм: система непересекающихся множеств (Union-Find)====

Во всех алгоритмах решения задачи требуется отслеживать, каким уже построенным фрагментам дерева принадлежат те или иные вершины графа. Для этого используется структура данных «система непересекающихся множеств» (Union-Find). Данная структура поддерживает две операции:

1. <math>FIND(v) = w</math> – по вершине v возвращает вершину w – «корень» фрагмента, которому принадлежит вершина v. При этом гарантируется, что вершины u и v принадлежат одному и тому же фрагменту, тогда и только тогда, когда <math>FIND(u) = FIND(v)</math>.

2. <math>MERGE(u, v)</math> – объединяет два фрагмента, которым принадлежат вершины <math>u</math> и <math>v.</math> (Если они уже лежат в одном фрагменте, то ничего не происходит.) При практической реализации удобно, чтобы данная операция возвращала значение истина, если объединение фрагментов имело место, и ложь в противном случае.

==== Последовательная версия====

Классический последовательный алгоритм Union-Find описан в статье Тарьяна. Каждой вершине v приписывается указатель на вершину-родителя <math>parent(v)</math>.

1. Изначально <math>parent(v) := v</math> для всех вершин.

2. <math>FIND(v)</math> выполняется следующим образом: полагаем <math>u := v</math>, и далее следуем по указателям <math>u := parent(u)</math> до тех пор, пока не станет <math>u = parent(u)</math>. Это и будет результат операции. Дополнительно можно «схлопывать» дерево: присвоить всем посещённым вершинами: <math>parent(u_i) := u</math>, либо производить схлопывание по пути: <math>parent(u) := parent(parent(u)))</math>.

3. <math>MERGE(u, v)</math> выполняется следующим образом: вначале находим корневые вершины <math>u := FIND(u), v := FIND(v)</math>. Если <math>u = v</math>, то исходные вершины принадлежат одному фрагменту и объединения фрагментов не происходит. В противном случае полагаем одно из <math>parent(u) := v</math> или <math>parent(v) := u</math>. Дополнительно можно отслеживать количество вершин в каждом из фрагментов, чтобы меньший фрагмент подсоединять к большему, а не наоборот (оценки сложности доказываются именно при такой реализации, однако на практике алгоритм хорошо работает и без подсчёта количества вершин).

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

1. В самом начале каждая вершина является отдельным фрагментом.

2. На каждом шаге:

* Для каждого фрагмента определяется минимальное по весу исходящее ребро.

* Минимальные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты объединяются.

3. Алгоритм останавливается, когда остаётся только один фрагмент, либо когда ни у одного из фрагментов нет исходящих рёбер.

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

Объединение фрагментов также может быть реализовано параллельно, с использованием описанной выше параллельной версии структуры Union-Find.

Аккуратный подсчёт количества активных фрагментов позволяет остановить алгоритм Борувки на один шаг раньше обычного:

1. В начале итерации счётчик активных фрагментов обнуляется.

2. На этапе поиска минимальных рёбер счётчик увеличивается на единицу для каждого фрагмента, у которого были исходящие рёбра.

3. На этапе объединения фрагментов счётчик уменьшается на единицу каждый раз, когда операция <math>MERGE(u, v)</math> вернула значение истина.

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

=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма Борувки для графа с <math>n</math> вершинами и <math>m</math> рёбрами составляет <math>O(m \ln(n))</math> операций.

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

В описанном подходе существует два уровня параллелизма: параллелизм в классическом алгоритме Борувки (нижний), и параллелизм в алгоритме обработка графа, не помещающегося в память.

'''Нижний уровень параллелизма''': поиск минимальных исходящих рёбер может выполняться независимо для каждого фрагмента, благодаря чему данную стадию вычислений можно эффективно параллелизовать (как на GPU, так и на CPU). Объединение фрагментов также может быть реализовано параллельно, с использованием описанной структуры Union-Find.

'''Верхний уровень параллелизма''': построение отдельных минимальных основных деревьев для каждого из списков ребер может производиться параллельно. Например, список ребер может разбиваться на две части, одна из которых обрабатывается на GPU, а вторая параллельно на CPU.

[[file:MST low.png|thumb|center|1000px|Рисунок 1. Информационный граф нижнего уровня параллелизма]]

Рассмотрим информационные графы и подробное описание каждого из них. Так же можно считать, что на рисунке 1 представлен информационный граф классического алгоритма Борувки, а на рисунке 2 — алгоритма обработки графа.

Нижний уровень параллелизма на графе алгоритма (рисунок 1) расположен на уровнях {3, 4, 5}, соответствующим операциям параллельного поиска минимальных исходящих ребер, а так же уровнях {6, 7, 8}, соответствующим операциям параллельного объединения деревьев. Так же, различные операции копирования {1, 2, 8, 9} выполняются параллельно. После выполнения тела цикла, производится проверка {12} того, сколько деревьев осталось на текущем шаге, и если данное число не изменилось, то происходит выход из цикла, иначе аналогичная следующая итерация.

Верхний уровень параллелизма (рисунок 2), как уже говорилось, заключается в параллельном вычислении минимального основного дерева (compute mst) для различных частей графа. Перед этим производится процесс инициализации (init process), данные которого используют последующие параллельные compute mst. Затем, после параллельных вычислений mst, происходит вычисление итого основного дерево, после чего после чего полученный результат сохраняется (save results).

[[file:MST up.png|thumb|center|1000px|Рисунок 2. Информационный граф верхнего уровня параллелизма]]

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

Алгоритму Борувки обладает большим потенциалом параллелизма, так как его основная операция (выбор минимального исходящего ребра во фрагменте) может исполнятся независимо для каждого фрагмента.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j},
v^{(2)}_{j})</math> с весами <math>f_j</math>).

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': список рёбер минимального остовного дерева (для несвязного графа – список минимальных остовных деревьев для всех компонент связности).

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===
# Алгоритм останавливается за конечное число шагов, поскольку на каждом шаге становится по крайней мере на один фрагмент меньше.
# Более того, число фрагментов на каждом шаге уменьшается как минимум вдвое, так что общее число шагов составляет не более <math>\log_2 n</math>. Отсюда следует и оценка сложности алгоритма.

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

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

На этапе поиска минимального ребра происходят следующие обращения к памяти:
# Чтение информации о рёбрах. Может производится последовательно.
# Проверка принадлежности ребра одному и тому же фрагменту - два чтения массива <math>parent(u)</math> с вероятным промахой по кэшу.
# Чтение и обновление минимального веса ребра фрагмента. Данная информация может быть закеширована, особенно на поздних шагах, однако обновление необходимо производить атомарно, что требует инвализации кэша.

На этапе схлопывания фрагментов требуется атомарно обновить массив <math>parent(u)</math> для каждого добавляемого в MST ребра. В зависимости от реализации параллельной структуры Union-Find корни фрагментов могут находиться ближе к началу массива, что позволяет закешировать эту наиболее часто читаемую область. Требование атомарности, однако, ограничивает эффект от такого кэширования.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:boruvka_1.png|thumb|center|700px|Рисунок 3. Алгоритм Борувки. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации алгоритма Борувки. Этот алгоритм, как и большинство графовых алгоритмов, обладает нерегулярной структурой. Сразу нужно отметить, что локальность реализаций таких алгоритмов во многом зависит от структуры входного графа и может существенно меняться. В данном случае мы рассматриваем лишь один из возможных вариантов.

Можно увидеть, что общий профиль состоит из 4 достаточно схожих этапов (разделены на рис. 3 вертикальными линиями). Однако поскольку этот профиль не обладает регулярной структурой, лучше рассмотреть все этапы.

Начнем с изучения верхней части профиля (фрагмент 1 на рис. 3), которая показана на рис. 4. На каждом этапе большую часть обращений занимает последовательный перебор всех элементов данного фрагмента (выделен на рис. 4 желтым). Остальные обращения на разных этапах устроены по-разному. Если на первом этапе эти обращения разбросаны достаточно далеко друг от друга, что приводит к низкой пространственной и временной локальности, то на последнем этапе почти все обращения (не считая последовательного перебора) выполняются к одному и тому же элементу, что, естественно, характеризуется очень высокой локальностью. Подобное строение всего фрагмента приводит, скорее всего, к средним значениям и по пространственной, и по временной локальности.

[[file:boruvka_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 1]]

Далее перейдем к изучению фрагмента 2 (рис. 5). Здесь можно увидеть, что строение каждого из 4 этапов отличается достаточно сильно. Как и в случае с фрагментом 1, каждый следующий этап обладает более высокой локальностью, однако здесь это заметно сильнее. При этом отметим, что данный фрагмент задействует всего около 60 элементов, а обращений к ним выполняется достаточно много, так что локальность в данном случае будет высока.

[[file:boruvka_3.png|thumb|center|700px|Рисунок 5. Профиль обращений, фрагмент 2]]

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

[[file:boruvka_4.png|thumb|center|700px|Рисунок 6. Профиль обращений, фрагмент 3]]

Отдельное рассмотрение фрагмента 4 (рис. 7) позволяет увидеть, что локальность здесь определяется 4 последовательными переборами всех элементов данного фрагмента. Эти переборы обладают стандартной структурой – шаг по памяти 1, только 1 обращение к каждому элементу; небольшое искривление данных переборов вызвано нерегулярной активностью в других фрагментах, которая приводит к искажению визуального представления профиля. Подобный набор обращений обладает высокой пространственной, но низкой временной локальностью.

[[file:boruvka_5.png|thumb|center|500px|Рисунок 7. Профиль обращений, фрагмент 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 8 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно неплоха – значение daps сравнимо, например, со значением для реализации метода Холецкого. Однако это значение заметно ниже самых производительных реализаций алгоритмов (например, теста Linpack), что в целом неудивительно в случае графовых алгоритмов, традиционно неэффективно работающих с памятью.

[[file:boruvka_daps.png|thumb|center|700px|Рисунок 8. Сравнение значений оценки daps]]

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

1. части, отвечающей за общую координацию вычислений

2. части, отвечающей за параллельные вычисления на многоядерных CPU или GPU.

Описанный выше последовательный алгоритм не может применяться в параллельной программе: в реализации <math>MERGE</math> результаты операций <math>FIND(u)</math> и <math>FIND(v)</math> могут постоянно меняться, что приведёт к race condition. Параллельный вариант алгоритма описан в статье.

1. Каждой вершине v соответствует запись <math>A[v] = { parent, rank }</math>. Изначально <math>A[v] := { v, 0 }</math>.

2. Вспомогательная операция <math>UPDATE(v, rank_v, u, rank_u)</math>:

old := A[v]

if old.parent != v or old.rank != rank_v then return false

new := { u, rank_u }

return CAS(A[v], old, new)

3. Операция <math>FIND(v)</math>:

while v != A[v].parent do
u := A[v].parent
CAS(A[v].parent, u, A[u].parent)
v := A[u].parent
return v

4. Операция UNION(u, v):

while true do
(u, v) := (FIND(u), FIND(v))
if u = v then return false
(rank_u, rank_v) := (A[u].rank, A[v].rank)
if (A[u].rank, u) > (A[v].rank, v) then
swap((u, rank_u), (v, rank_v))
if UPDATE(u, rank_u, v, rank_u) then
if rank_u = rank_v then
UPDATE(v, rank_v, v, rank_v + 1)
return true

Для описанной версии алгоритма гарантируется свойство wait-free. На практике может использоваться упрощённая версия без подсчёта рангов, обладающая более слабым свойством lock-free, но в ряде случаев выигрывающая по скорости.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Борувки согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости и масштабируемости вширь реализации алгоритма Борувки.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера

[[file:MST scaling strong.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма Борувки масштабируемость CPU версии: производительность в зависимости от числа запущенных CPU-потоков.]]

[[file:MST scaling wide.png|thumb|center|700px|Рисунок 4. Параллельная реализация алгоритма Борувки масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Борувки, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Борувки, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Boruvka cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

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

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

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

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Борувки]]

На графике скорости передачи данных в пакетах в секунду наблюдается аналогичная картина очень высокой интенсивности на первом этапе выполнения задачи. Далее сеть почти не используется.

В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала стабильно интенсивно, однако очень неэффективно использовала память из-за очень большого размера графа.

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

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]; функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают алгоритм Борувки и [[алгоритм Крускала]].

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

<references />

[[Категория:Начатые статьи]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2017-01-19T12:26:24Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:81] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 4.763e-05%;
* максимальная эффективность реализации 0.011%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD Perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSYTRD eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация метода Хаусхолдера, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdgehrd). Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, сеть FDR Infiniband а также компилятор Intel с опциями, рекомнедованными Intel MKL Advisor.
На рисунках показана эффективность реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду для размерности матрицы 15000, запуск проводился на 81 ядре.

[[file:PDGETRD cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике загрузки процессора видно, что почти все время работы программы средний уровень загрузки составляет около 90%. Это хорошая картина для программ, запущенных c использованием технологии Hyper Threading т.е. всех виртуальных ядер доступных для данной архитектуры. К концу итерации виден более высокий уровень интенсивности вычислений в срванении со началом и серединой вычислений.

[[file:PDGETRD LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

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

[[file:PDGETRD L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов первого уровня видно, что число промахов достаточно низкое и находится на уровне 5 млн/сек в среднем по всем узлам. Интересен факт снижения числа промахов к концу итерации, хотя снижение и не очень значительное, но вполне заметное.

[[file:PDGETRD L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже низкое и находится на уровне 1 млн/сек в среднем по всем узлам. На графике промахов второго уровня факт снижения числа промахов к концу итерации проявляется более явно и снижение и более значительное и заметное (с 1.2 млн до 0.5 млн.).

[[file:PDGETRD L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов последнего уровня видно, что число промахов достаточно небольшое и быстро убывает с уровня 90 тыс/сек до 0 в среднем по всем узлам. Это указывает на то, что задача достаточно хорошо укладывается в кэш-память третьего уровня, особенно к концу итерации.
[[file:PDGETRD Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно низкая интенсивность использования коммуникационной сети на каждой итерации. Причем к концу каждой итерации интенсивность передачи данных сильно снижается. Это указывает на бОльшую необходимость в обмене данными между процессами в начале итерации и большую локальность вычислений к концу итерации.
[[file:PDGETRD Inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

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

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

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2017-01-19T12:25:04Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:100] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 0.00012%;
* максимальная эффективность реализации 0.0416%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF perf2.png|thumb|center|700px|Рисунок 7. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF eff2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация метода Хаусхолдера, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdgehrd). Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, сеть FDR Infiniband а также компилятор Intel с опциями, рекомнедованными Intel MKL Advisor.
На рисунках показана эффективность реализации метода Хаусхолдера (отражений) QR-разложения квадратной матрицы для размерности матрицы 20000, запуск проводился на 100 ядрах, выполнялось 11 итераций.
[[file:PDGEQRF cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике загрузки процессора видно, что почти все время работы программы средний уровень загрузки составляет около 85%. Это хорошая картина для программ, запущенных c использованием технологии Hyper Threading т.е. всех виртуальных ядер доступных для данной архитектуры. К концу итерации виден более высокий уровень интенсивности вычислений в срванении со началом и серединой вычислений.

[[file:PDGEQRF LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно снижается со среднего значения 100 и к концу итерации снижается до 80. Это указывает на изменяющуюся загрузку аппаратных ресурсов процессами, однако их число для узла слишком велико, что с одной стороны может указывать на не очень рациональные опции компиляции, которые могут приводить к снижению производительности из-за накладных расходов на переключение контекста между нитями.

[[file:PDGEQRF L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике кэш-промахов первого уровня видно, что число промахов достаточно низкое и находится на уровне 5 млн/сек в среднем по всем узлам. Интересен факт снижения числа промахов к концу каждой итерации, хотя снижение и не очень значительное, но вполне заметное.

[[file:PDGEQRF L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже низкое и находится на уровне 1 млн/сек в среднем по всем узлам. На графике промахов второго уровня факт снижения числа промахов к концу итерации проявляется более явно и снижение и более значительное и заметное (с 1.2 млн до 0.5 млн.).

[[file:PDGEQRF L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике кэш-промахов последнего уровня видно, что число промахов достаточно небольшое и быстро убывает с уровня 75 тыс/сек до 20 тыс/сек в среднем по всем узлам. Это указывает на то, что задача достаточно хорошо укладывается в кэш-память третьего уровня, особенно к концу итерации.

[[file:PDGEQRF Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно низкая интенсивность использования коммуникационной сети на каждой итерации. Причем к концу каждой итерации интенсивность передачи данных сильно снижается. Это указывает на бОльшую необходимость в обмене данными между процессами в начале итерации и большую локальность вычислений к концу итерации. Наблюдается так же разбалансированность пересылок между максимальной и минимальной интенсивностью среди использованных узлов.

[[file:PDGEQRF Inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе метода Хаусхолдера (отражений) QR-разложения квадратной матрицы]]

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

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

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2017-01-17T22:40:05Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:81] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 4.763e-05%;
* максимальная эффективность реализации 0.011%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD Perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSYTRD eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация Метод Хаусхолдера, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdgehrd). Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, сеть FDR Infiniband а также компилятор Intel с опциями, рекомнедованными Intel MKL Advisor.
На рисунках показана эффективность реализации Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду для размерности матрицы 15000, запуск проводился на 81 ядре.

[[file:PDGETRD cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике загрузки процессора видно, что почти все время работы программы средний уровень загрузки составляет около 90%. Это хорошая картина для программ, запущенных c использованием технологии Hyper Threading т.е. всех виртуальных ядер доступных для данной архитектуры. К концу итерации виден более высокий уровень интенсивности вычислений в срванении со началом и серединой вычислений.

[[file:PDGETRD LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

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

[[file:PDGETRD L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов первого уровня видно, что число промахов достаточно низкое и находится на уровне 5 млн/сек в среднем по всем узлам. Интересен факт снижения числа промахов к концу итерации, хотя снижение и не очень значительное, но вполне заметное.

[[file:PDGETRD L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже низкое и находится на уровне 1 млн/сек в среднем по всем узлам. На графике промахов второго уровня факт снижения числа промахов к концу итерации проявляется более явно и снижение и более значительное и заметное (с 1.2 млн до 0.5 млн.).

[[file:PDGETRD L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике кэш-промахов последнего уровня видно, что число промахов достаточно небольшое и быстро убывает с уровня 90 тыс/сек до 0 в среднем по всем узлам. Это указывает на то, что задача достаточно хорошо укладывается в кэш-память третьего уровня, особенно к концу итерации.
[[file:PDGETRD Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно низкая интенсивность использования коммуникационной сети на каждой итерации. Причем к концу каждой итерации интенсивность передачи данных сильно снижается. Это указывает на бОльшую необходимость в обмене данными между процессами в начале итерации и большую локальность вычислений к концу итерации.
[[file:PDGETRD Inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе метода Хаусхолдера (отражений) приведения матрицы к трёхдиагональному виду]]

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

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

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме

2017-01-17T14:19:29Z

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

{{algorithm
| name = Приведение матрицы к двудиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{8 n^3}{3}+O(n^2)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 2)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к двухдиагональному виду, или, что то же самое, для разложения <math>A=QDU^T</math> (<math>Q, U</math> - ортогональные, <math>D</math> — правая двухдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрицы <math>Q, U</math> хранятся и используются не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием двух одномерных дополнительных массивов.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения разложения матрицы в произведение двухдиагональной и двух ортогональных используются попеременные умножения слева и справа её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

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

На каждом из шагов метода матрицы отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится для левых матриц отражения через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

Аналогично для правых матриц отражений <math>U=E-\frac{1}{\gamma}vv^*</math> <math>v</math> находится через координаты текущей <math>i</math>-й строки так:

<math>s</math> - вектор размерности <math>n-i</math>, составленный из элементов <math>i</math>-й строки, начиная с <math>i+1</math>-го элемента.

Если <math>(s,s)=0</math>, то <math>v=e_{i+1}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i+1</math>, <math>v_{j}=u_{j-i+2}</math> при <math>j>i+1</math>, а <math>v_{i+1}=1</math>, если <math>u_{1}=0</math> и <math>v_{i+1}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i+1}|</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>, и затем вычисления на каждом шагу (кроме шага с номером <math>i=n-1</math>) скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстрок <math>x</math> снизу от текущей, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

Всё приведение состоит из <math>2n-3</math> полушагов. Каждый из них состоит из вычисления некоторой матрицы отражений (Хаусхолдера) и умножения на неё матрицы. Строгая последовательность выполнения этих частей полушагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца, заканчивая <math>(n-1)</math>-м, попеременно с последовательным "обнулением" наддиагональных (кроме первой кодиагонали) элементов строк, начиная с 1й строки и заканчивая <math>(n-2)</math>-й

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i-1}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{2i-1}</math> на текущую версию матрицы.

В каждой "обнуляемой" <math>i</math>-й строке "обнуляются" сразу все его наддиагональные элементы одновременно, с <math>(i+2)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-й строки состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i}</math> такой, чтобы при умножении на неё справа "обнулились" все (кроме первого) наддиагональные её элементы;
б) умножение справа матрицы отражения <math>U_{2i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>4n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф нечётного полушага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего полушага), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего и жёлтых кружков - выходные для алгоритма.]]

На рисунке 1 изображён граф нечётного (<math>(2i-1)</math>го) полушага в привязке к элементам обрабатываемой матрицы. Граф чётного (<math>2i</math>го) полушага почти аналогичен, только длина ветвей (нарисована слева) будет меньше на 1 (<math>n-i</math>), и для привязки к элементам матрицы его надо отразить относительно диагонали матрицы. После этого отражения графы полушагов можно положить друг на друга слоями, при этом правые нижние углы должны быть друг над другом.

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций. Вычисления при "обнулении" <math>i</math>-й строки параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i-1</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''.

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Объём выходных данных''': <math>n^2+2n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной вещественной матрицы к двудиагональной форме на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2
DO K = I+1, N
SX(K)=2
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

IF (I.LT.N-1) THEN

DO K = I, N
SL(K)=A(I,N)*A(K,N)
END DO
DO J = N-1, I+1, -1
DO K = I, N
SL(K)=SL(K)+A(I,J)*A(K,J)
END DO
END DO

ALPHA = SQRT (SL(I))
IF (A(I,I+1).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = A(I,I+1)*BETA+SIGN(1.,A(I,I+1))
A(I,I+1)=ALPHA
G=1./ABS(SL(I)) ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SX(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = -1.
A(I,I+1)=ALPHA
G=1. ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SL(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
SL(I)=1
G=2.
DO K = I+1, N
SL(K)=2.
A(K,I+1) = A(K,I+1)-SL(K)
END DO
END IF
END IF

END IF
END DO
</source>

В этом варианте D расположена в диагонали и верхней кодиагонали массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов или надддиагональных - строк, а их первые элементы - в элементах массивов SX и SL.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qdu_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме. Общий профиль обращений в память]]

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

На рис. 3 показаны обращения в рамках первой итерации общего профиля (выделена на рис. 2 зеленым). Эти обращения можно условно разбить на несколько фрагментов. Фрагменты 1, 2 и 6 практически идентичны (различие заключается только в перестановке местами двух частей этих фрагментов), рассмотрим один из них.

[[file:householder_qdu_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

На рис. 4 показан отдельно фрагмент 6, выделенный на рис. 3. Теперь можно определить структуру каждой из двух частей более точно. Первая часть представляет собой последовательный перебор элементов в обратном порядке, причем к каждому элементу выполняется несколько обращений подряд. Во второй части также наблюдается последовательный перебор, однако с другими свойствами: элементы перебираются в прямом порядке, к каждому элементу выполняется только 1 обращение, однако данный перебор повторяется несколько раз подряд, причем каждый раз задействованы одни и те же элементы. Все это позволяет говорить о высокой пространственной локальности фрагмента (поскольку шаг по памяти каждый раз небольшой) и достаточно высокой временной локальности (поскольку данные часто используются повторно).

[[file:householder_qdu_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 6]]

Свойства локальности во фрагментах 3 и 5 можно оценить и без более детального рассмотрения. Данные в обоих фрагментах перебираются с достаточно большим шагом по памяти, при этом повторно они почти не используются, что говорит о низкой локальности в обоих случаях (хотя надо отметить, что локальность фрагмента 5 немного выше из-за более высокой пространственной локальности).

Теперь перейдем к рассмотрению фрагмента 4, расположенного в центре рис. 3. Поскольку он обладает регулярной структурой, достаточно более детально изучить небольшой фрагмент (представлен на рис. 5, выделен на рис. 3 зеленым). Здесь можно увидеть, что первая часть фрагмента представляет собой практически стандартный последовательный перебор (с небольшими нечастыми сдвигами, которые не влияют на локальность). Такой набор обращений обладает высокой пространственной и низкой временной локальностью. Вторая часть данного фрагмента устроена несколько сложнее – она состоит из L-образных наборов обращений. Одна его область (часть 1 на рис. 5) по строению очень похожа на первую часть; вторая (часть 2 на рис. 5) представляет собой набор обращений к одному и тому же элементу, что достаточно сильно повышает локальность данного фрагмента. Из этого можно сделать вывод, что фрагмент 4 обладает высокой пространственной и средней временной локальностью.

[[file:householder_qdu_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмент 4]]

Суммируя выше сказанное, можно сказать, что фрагменты 1, 2 и 6 обладают высокой локальностью; фрагменты 3 и 5 – низкой локальностью; фрагмент 4 – высокой пространственной и средней временной локальностью. Можно предположить, что в итоге локальность общего профиля будет не очень высокой, в основном из-за более низкой временной локальности. Однако такое достаточно сложное строение общего профиля затрудняет оценку локальности общего профиля на основе визуального анализа.

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что оценка производительности в данном случае не очень высока, что подтверждает сделанные ранее выводы. В частности, значение daps для этого примера показывает более низкую производительность по сравнению с реализациями других методов Хаусхолдера (householder_qr householder_qtq) и находится примерно на уровне оценки для реализации метода Холецкого.

[[file:householder_qdu_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:100] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 5.033e-05%;
* максимальная эффективность реализации 0.0135%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD perf2.png|thumb|center|700px|Рисунок 7. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD eff2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация Метод Хаусхолдера, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdgehrd). Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, сеть FDR Infiniband а также компилятор Intel с опциями, рекомнедованными Intel MKL Advisor.
На рисунках показана эффективность реализации метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме для размерности матрицы 16000, запуск проводился на 100 ядрах.

[[file:PDGEHRD CPU.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 90%. Это хорошая картина для программ, запущенных c использованием технологии Hyper Threading т.е. всех виртуальных ядер доступных для данной архитектуры.

[[file:PDGEHRD Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

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

[[file:PDGEHRD L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной формеy]]

На графике кэш-промахов первого уровня видно, что число промахов достаточно низкое и находится на уровне 4 млн/сек в среднем по всем узлам. Интересен факт снижения числа промахов к концу итерации, хотя снижение и не очень значительное, но вполне заметное.

[[file:PDGEHRD L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже низкое и находится на уровне 1 млн/сек в среднем по всем узлам. На графике промахов второго уровня факт снижения числа промахов к концу итерации проявляется более явно и снижение и более значительное и заметное (с 1.4 млн до 0.8 млн.).

[[file:PDGEHRD L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

На графике кэш-промахов последнего уровня видно, что число промахов достаточно небольшое и быстро убывает с уровня 127 тыс/сек до 0 в среднем по всем узлам. Это указывает на то, что задача достаточно хорошо укладывается в кэш-память третьего уровня, особенно к концу итерации.
[[file:PDGEHRD inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно низкая интенсивность использования коммуникационной сети на каждой итерации. Причем к концу каждой итерации интенсивность передачи данных сильно снижается. Это указывает на бОльшую необходимость в обмене данными между процессами в начале итерации и большую локальность вычислений к концу итерации.
[[file:PDGEHRD inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе метода Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме]]

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

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

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для приведения матриц к двудиагональному виду именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Разложение Холецкого (метод квадратного корня)

2017-01-17T13:43:11Z

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

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n (n + 1)}{2}</math>
| output_data = <math>\frac{n (n + 1)}{2}</math>
}}

Основные авторы описания: [[Участник:Frolov|А.В.Фролов]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]]), [[Участник:Teplov|А.М.Теплов]] (разделы [[#Масштабируемость алгоритма и его реализации|2.4]], [[#Динамические характеристики и эффективность реализации алгоритма|2.5]])

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

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

'''Разложение Холецкого''' впервые предложено французским офицером и математиком Андре-Луи Холецким в конце Первой Мировой войны, незадолго до его гибели в бою в августе 1918 г. Идея этого разложения была опубликована в 1924 г. его сослуживцем<ref>Commandant Benoit, Note sur une méthode de résolution des équations normales provenant de l'application de la méthode des moindres carrés à un système d'équations linéaires en nombre inférieur à celui des inconnues (Procédé du Commandant Cholesky), Bulletin Géodésique 2 (1924), 67-77.</ref>. Потом оно было использовано поляком Т. Банашевичем<ref>Banachiewicz T. Principles d'une nouvelle technique de la méthode des moindres carrês. Bull. Intern. Acad. Polon. Sci. A., 1938, 134-135.</ref><ref>Banachiewicz T. Méthode de résoltution numérique des équations linéaires, du calcul des déterminants et des inverses et de réduction des formes quardatiques. Bull. Intern. Acad. Polon. Sci. A., 1938, 393-401.</ref> в 1938 г. В советской математической литературе называется также методом квадратного корня<ref>Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref><ref>Воеводин В.В., Кузнецов Ю.А. Матрицы и вычисления. М.: Наука, 1984.</ref><ref>Фаддеев Д.К., Фаддева В.Н. Вычислительные основы линейной алгебры. М.-Л.: Физматгиз, 1963.</ref>; название связано с характерными операциями, отсутствующими в родственном разложении Гаусса.

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

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

Варианты разложения Холецкого нашли успешные применения и в итерационных методах для построения переобусловливателей разреженных симметричных положительно определенных матриц. В неполном треугольном разложении («по позициям») элементы переобусловливателя вычисляются только в заранее заданных позициях, например, в позициях ненулевых элементов исходной матрицы (так называемое разложение IC0). Для получения же более точного разложения применяется приближение, в котором фильтрация малых элементов производится «по значениям». В зависимости от используемого порога фильтрации можно получить более точное, но и более заполненное разложение. Существует и алгоритм разложения второго порядка точности<ref>Kaporin I.E. High quality preconditioning of a general symmetric positive definite matrix based on its UTU + UTR + RTU-decomposition. Numer. Lin. Algebra Appl. (1998) Vol. 5, No. 6, 483-509.</ref>. В нём при таком же заполнении множителей разложения удается улучшить точность. Для такого разложения в параллельном режиме используется специальный вариант аддитивного переобуславливания на основе разложения второго порядка<ref>Капорин И.Е., Коньшин И.Н. Параллельное решение симметричных положительно-определенных систем на основе перекрывающегося разбиения на блоки. Ж. вычисл. матем. и матем. физ., 2001, Т, 41, N. 4, C. 515–528.</ref>.

На этой странице представлено исходное разложение Холецкого с новых позиций нашего суперкомпьютерного века. Приведено описание конкретной версии разложения Холецкого — для плотных вещественных симметричных положительно определённых матриц, но структура для ряда других версий, например, для комплексного случая, почти такая же, различия состоят в замене большинства вещественных операций на комплексные. Список остальных основных вариантов разложения можно посмотреть на странице [[Метод Холецкого (нахождение симметричного треугольного разложения)]].

Используется для разложения положительно определённых эрмитовых (''в вещественном случае - симметрических'') матриц в виде <math>A = L L^*</math>, <math>L</math> — нижняя треугольная матрица,
{{Шаблон:LCommon}}
или в виде <math>A = U^* U</math>, <math>U</math> — верхняя треугольная матрица,
{{Шаблон:UCommon}}
Эти разложения совершенно эквивалентны друг другу по вычислениям и различаются только способом представления данных). Он заключается в реализации формул для элементов матрицы <math>L</math>, получающихся из вышеприведённого равенства единственным образом. Получило широкое распространение благодаря следующим особенностям.

==== Симметричность и положительная определённость матрицы ====

Симметричность матрицы позволяет хранить и вычислять только чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций в сравнении с, например, разложением по методу Гаусса. При этом альтернативное (без вычисления квадратных корней) LU-разложение, использующее симметрию матрицы, всё же несколько быстрее метода Холецкого (не использует извлечение квадратных корней), но требует хранения всей матрицы.
Благодаря тому, что разлагаемая матрица не только симметрична, но и положительно определена, её LU-разложения, в том числе и разложение методом Холецкого, имеют наименьшее ''[[Глоссарий#Эквивалентное возмущение|эквивалентное возмущение]]'' из всех известных разложений матриц.

==== Режим накопления ====

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

=== Математическое описание алгоритма ===

Исходные данные: положительно определённая симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: нижняя треугольная матрица <math>L</math> (элементы <math>l_{ij}</math>).

Формулы метода:
:<math>
\begin{align}
l_{11} & = \sqrt{a_{11}}, \\
l_{j1} & = \frac{a_{j1}}{l_{11}}, \quad j \in [2, n], \\
l_{ii} & = \sqrt{a_{ii} - \sum_{p = 1}^{i - 1} l_{ip}^2}, \quad i \in [2, n], \\
l_{ji} & = \left (a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp} \right ) / l_{ii}, \quad i \in [2, n - 1], j \in [i + 1, n].
\end{align}
</math>

Существует также блочная версия метода, однако в данном описании разобран только точечный метод.

В ряде реализаций деление на диагональный элемент выполняется в два этапа: вычисление <math>\frac{1}{l_{ii}}</math> и затем умножение на него всех (видоизменённых) <math>a_{ji}</math> . Здесь мы этот вариант алгоритма не рассматриваем. Заметим только, что он имеет худшие параллельные характеристики, чем представленный.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро последовательной версии метода Холецкого можно составить из множественных (всего их <math>\frac{n (n - 1)}{2}</math>) вычислений скалярных произведений строк матрицы:

:<math>\sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math>

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

:<math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math><nowiki/>

в которых и встречаются скалярные произведения, ведутся не в порядке «вычислили скалярное произведение, а потом вычли его из элемента», а путём вычитания из элемента покомпонентных произведений, являющихся частями скалярных произведений. Поэтому следует считать вычислительным ядром метода не вычисления скалярных произведений, а вычисления выражений

:<math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math>

в ''режиме накопления'' или без него.

Тем не менее, в популярных зарубежных реализациях точечного метода Холецкого, в частности, в библиотеках LINPACK и LAPACK, основанных на BLAS, используются именно вычисления скалярных произведений в виде вызова соответствующих подпрограмм BLAS (конкретно — функции SDOT). На последовательном уровне это влечёт за собой дополнительную операцию суммирования на каждый из <math>\frac{n (n + 1)}{2}</math> вычисляемый элемент матрицы <math>L</math> и некоторое замедление работы программы (о других следствиях рассказано ниже в разделе «[[#Существующие реализации алгоритма|Существующие реализации алгоритма]]»). Поэтому в данных вариантах ядром метода Холецкого будут вычисления этих скалярных произведений.

=== Макроструктура алгоритма ===

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>\frac{n (n - 1)}{2}</math>) вычисления сумм

:<math>a_{ji}-\sum_{p=1}^{i-1}l_{ip} l_{jp}</math>

в режиме накопления или без него.

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

Последовательность исполнения метода следующая:

1. <math>l_{11}= \sqrt{a_{11}}</math>

2. <math>l_{j1}= \frac{a_{j1}}{l_{11}}</math> (при <math>j</math> от <math>2</math> до <math>n</math>).

Далее для всех <math>i</math> от <math>2</math> до <math>n</math> по нарастанию выполняются

3. <math>l_{ii} = \sqrt{a_{ii} - \sum_{p = 1}^{i - 1} l_{ip}^2}</math> и

4. (кроме <math>i = n</math>): <nowiki/><math>l_{ji} = \left (a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp} \right ) / l_{ii}</math> (для всех <math>j</math> от <math>i + 1</math> до <math>n</math>).

После этого (если <math>i < n</math>) происходит переход к шагу 3 с бо́льшим <math>i</math>.

Особо отметим, что вычисления сумм вида <math>a_{ji} - \sum_{p = 1}^{i - 1} l_{ip} l_{jp}</math> в обеих формулах производят в режиме накопления вычитанием из <math>a_{ji}</math> произведений <math>l_{ip} l_{jp}</math> для <math>p</math> от <math>1</math> до <math>i - 1</math>, c нарастанием <math>p</math>.

=== Последовательная сложность алгоритма ===

Для разложения матрицы порядка n методом Холецкого в последовательном (наиболее быстром) варианте требуется:

* <math>n</math> вычислений квадратного корня,
* <math>\frac{n(n-1)}{2}</math> делений,
* <math>\frac{n^3-n}{6}</math> сложений (вычитаний),
* <math>\frac{n^3-n}{6}</math> умножений.

Умножения и сложения (вычитания) составляют ''основную часть алгоритма''.

При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности (или использования функции вроде DPROD в Фортране), что ещё больше увеличивает долю умножений и сложений/вычитаний во времени, требуемом для выполнения метода Холецкого.

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

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин, расположенных в целочисленных узлах трёх областей разной размерности.

'''Первая''' группа вершин расположена в одномерной области, соответствующая ей операция вычисляет функцию SQRT.
Единственная координата каждой из вершин <math>i</math> меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения.

Аргумент этой функции

* при <math>i = 1</math> — элемент ''входных данных'', а именно <math>a_{11}</math>;
* при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1</math>, <math>i</math>, <math>i - 1</math>.
Результат срабатывания операции является ''выходным данным'' <math>l_{ii}</math>.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a / b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>l_{ji}</math>.

'''Третья''' группа вершин расположена в трёхмерной области, соответствующая ей операция <math>a - b * c</math>.
Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>2</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i</math> до <math>n</math>, принимая все целочисленные значения;
* <math>p</math> — меняется в диапазоне от <math>1</math> до <math>i - 1</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>p = 1</math> элемент входных данных <math>a_{ji}</math>;
** при <math>p > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i, j, p - 1</math>;
*<math>b</math> — результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>p, i</math>;
*<math>c</math> — результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>p, j</math>;

Результат срабатывания операции является ''промежуточным данным'' алгоритма.

Описанный граф можно посмотреть на рис.1 и рис.2, выполненных для случая <math>n = 4</math>. Здесь вершины первой группы обозначены жёлтым цветом и буквосочетанием sq, вершины второй — зелёным цветом и знаком деления, третьей — красным цветом и буквой f. Вершины, соответствующие операциям, производящим выходные данные алгоритма, выполнены более крупно. Дублирующие друг друга дуги даны как одна. На рис.1 показан граф алгоритма согласно классическому определению , на рис.2 к графу алгоритма добавлены вершины , соответствующие входным (обозначены синим цветом) и выходным (обозначены розовым цветом) данным.

[[file:Cholesky full.png|thumb|center|1400px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. SQ - вычисление квадратного корня, F - операция a-bc, Div - деление.]]
[[file:Cholesky full_in_out.png|thumb|center|1400px|Рисунок 2. Граф алгоритма с отображением входных и выходных данных. SQ - вычисление квадратного корня, F - операция a-bc, Div - деление, In - входные данные, Out - результаты.]]

<center>
{{#widget:Iframe
|url=https://algowiki-project.org/html/Algo_viewer_json/cholesky/Algo_viewer_example_2.html
|width=800
|height=600
|border=1
}}
 
Интерактивное изображение графа алгоритма без входных и выходных данных для n = 4.
</center>

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

Для разложения матрицы порядка <math>n</math> методом Холецкого в параллельном варианте требуется последовательно выполнить следующие ярусы:
* <math>n</math> ярусов с вычислением квадратного корня (единичные вычисления в каждом из ярусов),
* <math>n - 1</math> ярус делений (в каждом из ярусов линейное количество делений, в зависимости от яруса — от <math>1</math> до <math>n - 1</math>),
* по <math>n - 1</math> ярусов умножений и сложений/вычитаний (в каждом из ярусов — квадратичное количество операций, от <math>1</math> до <math>\frac{n^2 - n}{2}</math>.

Таким образом, в параллельном варианте, в отличие от последовательного, вычисления квадратных корней и делений будут определять довольно значительную долю требуемого времени. При реализации на конкретных архитектурах наличие в отдельных ярусах [[глоссарий#Ярусно-параллельная форма графа алгоритма|ЯПФ]] отдельных вычислений квадратных корней может породить и другие проблемы. Например, при реализации на ПЛИСах остальные вычисления (деления и тем более умножения и сложения/вычитания) могут быть конвейеризованы, что даёт экономию и по ресурсам на программируемых платах; вычисления же квадратных корней из-за их изолированности приведут к занятию ресурсов на платах, которые будут простаивать большую часть времени. Таким образом, общая экономия в 2 раза, из-за которой метод Холецкого предпочитают в случае симметричных задач тому же методу Гаусса, в параллельном случае уже имеет место вовсе не по всем ресурсам, и главное - не по требуемому времени.

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

При классификации по высоте ЯПФ, таким образом, метод Холецкого относится к алгоритмам со сложностью <math>O(n)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n^2)</math>.

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

'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.
* <math>A</math> – положительно определённая матрица, т. е. для любых ненулевых векторов <math>\vec{x}</math> выполняется <math>\vec{x}^T A \vec{x} > 0</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом. Например, в библиотеке, реализованной в НИВЦ МГУ, матрица A хранилась в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своего нижнего треугольника.

'''Выходные данные''': нижняя треугольная матрица <math>L</math> (элементы <math>l_{ij}</math>).

'''Объём выходных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу треугольности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом. Например, в той же библиотеке, созданной в НИВЦ МГУ, матрица <math>L</math> хранилась в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части.

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

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

При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – всего лишь ''линейна''.

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

Дуги информационного графа, исходящие из вершин, соответствующих операциям квадратного корня и деления, образуют пучки т. н. рассылок линейной мощности (то есть степень исхода этих вершин и мощность работы с этими данными — линейная функция от порядка матрицы и координат этих вершин). При этом естественно наличие в этих пучках «длинных» дуг. Остальные дуги локальны.

Наиболее известной является компактная укладка графа — его проекция на треугольник матрицы, который перевычисляется укладываемыми операциями. При этом «длинные» дуги можно убрать, заменив более дальнюю пересылку комбинацией нескольких ближних (к соседям).

[[Глоссарий#Эквивалентное возмущение|Эквивалентное возмущение]] <math>M</math> у метода Холецкого всего вдвое больше, чем возмущение <math>\delta A</math>, вносимое в матрицу при вводе чисел в компьютер:
<math>
||M||_{E} \leq 2||\delta A||_{E}
</math>

Это явление обусловлено положительной определённостью матрицы. Среди всех используемых разложений матриц это наименьшее из эквивалентных возмущений.

== Программная реализация алгоритма ==

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

В простейшем (без перестановок суммирования) варианте метод Холецкого на Фортране можно записать так:
<source lang="fortran">
DO I = 1, N
S = A(I,I)
DO IP=1, I-1
S = S - DPROD(A(I,IP), A(I,IP))
END DO
A(I,I) = SQRT (S)
DO J = I+1, N
S = A(J,I)
DO IP=1, I-1
S = S - DPROD(A(I,IP), A(J,IP))
END DO
A(J,I) = S/A(I,I)
END DO
END DO
</source>
При этом для реализации режима накопления переменная <math>S</math> должна быть двойной точности.

Отдельно следует обратить внимание на используемую в такой реализации функцию DPROD. Её появление как раз связано с тем, как математики могли использовать режим накопления вычислений. Дело в том, что, как правило, при выполнении умножения двух чисел с плавающей запятой сначала результат получается с удвоенными длинами мантиссы и порядка, и только при выполнении присваивания переменной одинарной точности результат округляется. Эта возможность даёт выполнять умножение действительных чисел с двойной точностью без предварительного приведения их к типу двойной точности. На ранних этапах развития вычислительных библиотек снятие результата без округление реализовали вставками специального кода в фортран-программы, но уже в 70-х гг. XX века в ряде трансляторов Фортрана появилась функция DPROD, реализующая это без обращения программиста к машинным кодам. Она была закреплена среди стандартных функций в стандарте Фортран 77, и реализована во всех современных трансляторах Фортрана.

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

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

Есть и другой вариант точечной схемы: использовать вычисляемые элементы матрицы <math>L</math> в качестве аргументов непосредственно «сразу после» их вычисления. Такая программа будет выглядеть так:
<source lang="fortran">
DO I = 1, N
A(I,I) = SQRT (A(I, I))
DO J = I+1, N
A(J,I) = A(J,I)/A(I,I)
END DO
DO K=I+1,N
DO J = K, N
A(J,K) = A(J,K) - A(J,I)*A(K,I)
END DO
END DO
END DO
</source>
Как видно, в этом варианте для реализации режима накопления одинарной точности мы должны будем объявить двойную точность для массива, хранящего исходные данные и результат. Подчеркнём, что [[глоссарий#Граф алгоритма|граф алгоритма]] обеих схем - один и тот же (из п.1.7), если не считать изменением замену умножения на функцию DPROD!

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

[[file:Cholesky_locality1.jpg|thumb|center|700px|Рисунок 3. Реализация метода Холецкого. Общий профиль обращений в память]]

На рис.3 представлен профиль обращений в память<ref>Воеводин Вад. В. Визуализация и анализ профиля обращений в память // Вестник Южно-Уральского государственного университета. Серия Математическое моделирование и про-граммирование. — 2011. — Т. 17, № 234. — С. 76–84.</ref><ref>Воеводин Вл. В., Воеводин Вад. В. Спасительная локальность суперкомпьютеров // Открытые системы. — 2013. — № 9. — С. 12–15.</ref> для реализации метода Холецкого. В программе задействован только 1 массив, поэтому в данном случае обращения в профиле происходят только к элементам этого массива. Программа состоит из одного основного этапа, который, в свою очередь, состоит из последовательности подобных итераций. Пример одной итерации выделен зеленым цветом.

Видно, что на каждой <math>i</math>-й итерации используются все адреса, начиная с некоторого, при этом адрес первого обрабатываемого элемента увеличивается. Также можно заметить, что число обращений в память на каждой итерации растет примерно до середины работы программы, после чего уменьшается вплоть до завершения работы. Это позволяет говорить о том, что данные в программе используются неравномерно, при этом многие итерации, особенно в начале выполнения программы, задействуют большой объем данных, что приводит к ухудшению локальности.

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

[[file:Cholesky_locality2.jpg|thumb|center|700px|Рисунок 4. Реализация метода Холецкого. Фрагмент профиля (несколько первых итераций)]]

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

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

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

[[file:Cholesky_locality3.jpg|thumb|center|700px|Рисунок 5. Реализация метода Холецкого. Фрагмент профиля (часть одной итерации)]]

Рис.5, на котором представлена часть одной итерации общего профиля (см. рис.3), позволяет отметить достаточно интересный факт: строение каждого из фрагментов на самом деле заметно сложнее, чем это выглядит на рис.4. В частности, каждый шаг фрагмента 1 состоит из нескольких обращений к соседним адресам, причем выполняется не последовательный перебор. Также можно увидеть, что фрагмент 2 на самом деле в свою очередь состоит из повторяющихся итераций, при этом видно, что каждый шаг фрагмента 1 соответствует одной итерации фрагмента 2 (выделено зеленым на рис.5). Это лишний раз говорит о том, что для точного понимания локальной структуры профиля необходимо его рассмотреть на уровне отдельных обращений.

Стоит отметить, что выводы на основе рис.5 просто дополняют общее представлении о строении профиля обращений; сделанные на основе рис.4 выводы относительно общей локальности двух фрагментов остаются верны.

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.algowiki-project.org/Voevodin/locality/blob/master/benchmarks/holecky/holecky.h здесь] (функция Kernel). Условия запуска описаны [http://git.algowiki-project.org/Voevodin/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

[[file:Cholesky_locality4.jpg|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

На рис.6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что реализация метода Холецкого характеризуется достаточно высокой скоростью взаимодействия с памятью, однако ниже, чем, например, у теста Линпак или реализации метода Якоби.

Вторая характеристика – cvg – предназначена для получения более машинно-независимой оценки локальности. Она определяет, насколько часто в программе необходимо подтягивать данные в кэш-память. Соответственно, чем меньше значение cvg, тем реже это нужно делать, тем лучше локальность.

[[file:Cholesky_locality5.jpg|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

На рис.7 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, согласно данной оценке, реализация метода Холецкого оказалась ниже в списке по сравнению с оценкой daps.

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

Как нетрудно видеть по структуре графа алгоритма, вариантов распараллеливания алгоритма довольно много. Например, во втором варианте (см. раздел «[[#Особенности реализации последовательного алгоритма|Особенности реализации последовательного алгоритма]]») все внутренние циклы параллельны, в первом — параллелен цикл по <math>J</math>. Тем не менее, простое распараллеливание таким способом «в лоб» вызовет такое количество пересылок между процессорами с каждым шагом по внешнему циклу, которое почти сопоставимо с количеством арифметических операций. Поэтому перед размещением операций и данных между процессорами вычислительной системы предпочтительно разбиение всего пространства вычислений на блоки, с сопутствующим разбиением обрабатываемого массива.

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

В принципе, возможно и использование т. н. «скошенного» параллелизма. Однако его на практике никто не использует, из-за усложнения управляющей структуры программы.

=== Масштабируемость алгоритма и его реализации ===

==== Масштабируемость алгоритма ====

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

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4 : 256] с шагом 4;
* размер матрицы [1024 : 5120].

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации разложения Холецкого в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость Параллельной реализации метода Холецкого Производительность3.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Холецкого. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Холецкий масштабируемость эффективность2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Холецкого. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации разложения Холецкого:
* По числу процессов: -0,000593. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска уменьшается, однако в целом уменьшение не очень быстрое. Малая интенсивность изменения объясняется крайне низкой общей эффективностью работы приложения с максимумом в 2,65%, и значение эффективности на рассмотренной области значений быстро доходит до десятых долей процента. Это свидетельствует о том, что на большей части области значений нет интенсивного снижения эффективности. Это объясняется также тем, что с ростом [[Глоссарий#Вычислительная сложность|вычислительной сложности]] падение эффективности становится не таким быстрым. Уменьшение эффективности на рассмотренной области работы параллельной программы объясняется быстрым ростом накладных расходов на организацию параллельного выполнения. С ростом вычислительной сложности задачи эффективность снижается так же быстро, но при больших значениях числа процессов. Это подтверждает предположение о том, что накладные расходы начинают сильно превалировать над вычислениями.
* По размеру задачи: 0,06017. При увеличении размера задачи эффективность возрастает. Эффективность возрастает тем быстрее, чем большее число процессов используется для выполнения. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается. Также, учитывая разницу максимальной и минимальной эффективности в 2,5%, можно сделать вывод, что рост эффективности при увеличении размера задачи наблюдается на большей части рассмотренной области значений.
* По двум направлениям: 0,000403. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров небольшая, эффективность с увеличением масштабов возрастает, но медленно и с небольшими перепадами.

[http://git.algowiki-project.org/Teplov/Scalability/tree/master/cholesky-decomposition-master Исследованная параллельная реализация на языке C]

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

Для проведения экспериментов использовалась реализация разложения Холецкого, представленная в пакете SCALAPACK библиотеки Intel MKL (метод pdpotrf). Все результаты получены на суперкомпьютере «Ломоносов»<ref name="Lom" />. Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор Intel с опцией –O2.
На рисунках показана эффективность реализации разложения Холецкого (случай использования нижних треугольников матриц) для размерности матрицы 80000, запуск проводился на 256 процессах.

[[file:Cholesky CPU.png|thumb|center|700px|Рисунок 10. График загрузки CPU при выполнении разложения Холецкого]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это хорошая картина для программ, запущенных без использования технологии Hyper Threading.

[[file:Cholesky FLOPS.png|thumb|center|700px|Рисунок 11. График операций с плавающей точкой в секунду при выполнении разложения Холецкого]]

На Рисунке 11 показан график количества операций с плавающей точкой в секунду. Видно, что к концу каждой итерации число операций возрастает.
[[file:Cholesky L1.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе разложения Холецкого]]

На графике кэш-промахов первого уровня видно, что число промахов достаточно большое и находится на уровне 25 млн/сек в среднем по всем узлам.
[[file:Cholesky L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе разложения Холецкого]]

На графике кэш-промахов третьего уровня видно, что число промахов все еще достаточно большое и находится на уровне 1,5 млн/сек в среднем по всем узлам. Это указывает на то, что задача достаточно большая, и данные плохо укладываются в кэш-память.
[[file:Cholesky MemRead.png|thumb|center|700px|Рисунок 14. График количества чтений из оперативной памяти при работе разложения Холецкого]]

На графике чтений из памяти на протяжении всего времени работы программы наблюдается достаточно интенсивная и не сильно изменяющаяся работа с памятью.
[[file:Cholesky MemWrite.png|thumb|center|700px|Рисунок 15. График количества записей в оперативную память при работе разложения Холецкого]]

На графике записей в память видна периодичность: на каждой итерации к концу выполнения число записей в память достаточно сильно падает. Это коррелирует с возрастанием числа операций с плавающей точкой и может объясняться тем, что при меньшем числе записей в память программа уменьшает накладные расходы и увеличивает эффективность.
[[file:Cholesky Inf Bps.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в байт/сек при работе разложения Холецкого]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно интенсивное использование коммуникационной сети на каждой итерации. Причем к концу каждой итерации интенсивность передачи данных сильно возрастает. Это указывает на большую необходимость в обмене данными между процессами к концу итерации.
[[file:Cholesky Inf Pps.png|thumb|center|700px|Рисунок 17. График скорости передачи по сети Infiniband в пакетах/сек при работе разложения Холецкого]]

На графике скорости передачи данных в пакетах в секунду наблюдается большая «кучность» показаний максимального минимального и среднего значений в сравнении с графиком скорости передачи в байт/сек. Это говорит о том, что, вероятно, процессы обмениваются сообщениями различной длины, что указывает на неравномерное распределение данных. Также наблюдается рост интенсивности использования сети к концу каждой итерации.
[[file:Cholesky LoadAVG.png|thumb|center|700px|Рисунок 18. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе разложения Холецкого]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с восьмью процессами на каждом узле. Это указывает на рациональную и статичную загрузку аппаратных ресурсов процессами.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно и стабильно. Использование памяти и коммуникационной среды достаточно интенсивное, что может стать фактором снижения эффективности при существенном росте размера задачи или же числа процессоров.
Для существующих параллельных реализаций характерно отнесение всего ресурса параллелизма на блочный уровень. Относительно низкая эффективность работы связана с проблемами внутри одного узла, следующим фактором является неоптимальное соотношение между «арифметикой» и обменами. Видно, что при некотором (довольно большом) оптимальном размере блока обмены влияют не так уж сильно.

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

Как видно по показателям SCALAPACK на суперкомпьютерах, обмены при большом n хоть и уменьшают эффективность расчётов, но слабее, чем неоптимальность организации расчётов внутри одного узла. Поэтому, видимо, следует сначала оптимизировать не блочный алгоритм, а подпрограммы, используемые на отдельных процессорах: точечный метод Холецкого, перемножения матриц и др. подпрограммы. [[#Существующие реализации алгоритма|Ниже]] содержится информация о возможном направлении такой оптимизации.

Вообще эффективность метода Холецкого для параллельных архитектур не может быть высокой. Это связано со следующим свойством информационной структуры алгоритма: если операции деления или вычисления выражений <math>a - bc</math> являются не только массовыми, но и параллельными, и потому их вычисления сравнительно легко выстраивать в конвейеры или распределять по устройствам, то операции извлечения квадратных корней являются узким местом алгоритма. Поэтому для эффективной реализации алгоритмов, столь же хороших по вычислительным характеристикам, как и метод квадратного корня, следует использовать не метод Холецкого, а его давно известную модификацию без извлечения квадратных корней — [[%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BD%D0%B0%D1%85%D0%BE%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_%D1%82%D1%80%D0%B5%D1%83%D0%B3%D0%BE%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F)#.5C.28LDL.5ET.5C.29_.D1.80.D0.B0.D0.B7.D0.BB.D0.BE.D0.B6.D0.B5.D0.BD.D0.B8.D0.B5|разложение матрицы в произведение <math>L D L^T</math>]]<ref>Krishnamoorthy A., Menon D. Matrix Inversion Using Cholesky Decomposition. 2013. eprint arXiv:1111.4144</ref>.

=== Существующие реализации алгоритма ===

Точечный метод Холецкого реализован как в основных библиотеках программ отечественных организаций, так и в западных пакетах LINPACK, LAPACK, SCALAPACK и др.

При этом в отечественных реализациях, как правило, выполнены стандартные требования к методу с точки зрения ошибок округления, то есть, реализован режим накопления, и обычно нет лишних операций. Ряд старых отечественных реализаций использует для экономии памяти упаковку матриц <math>A</math> и <math>L</math> в одномерный массив.

Реализация точечного метода Холецкого в современных западных пакетах обычно происходит из одной и той же реализации метода в LINPACK, а та использует пакет BLAS. В BLAS скалярное произведение реализовано без режима накопления, но это легко исправляется при желании.

Интересно, что в крупнейших библиотеках алгоритмов до сих пор предлагается именно разложение Холецкого, а более быстрый алгоритм LU-разложения без извлечения квадратных корней используется только в особых случаях (например, для трёхдиагональных матриц), в которых количество диагональных элементов уже сравнимо с количеством внедиагональных.

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

<references \>

[[en:Cholesky decomposition]]

[[Категория:Законченные статьи]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2017-01-10T13:14:03Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:100] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 0.00012%;
* максимальная эффективность реализации 0.0416%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF perf2.png|thumb|center|700px|Рисунок 7. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF eff2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2017-01-10T13:13:27Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:100] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 0.00012%;
* максимальная эффективность реализации 0.0416%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2017-01-10T13:12:08Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме

2017-01-06T14:20:09Z

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

{{algorithm
| name = Приведение матрицы к двудиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{8 n^3}{3}+O(n^2)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 2)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к двухдиагональному виду, или, что то же самое, для разложения <math>A=QDU^T</math> (<math>Q, U</math> - ортогональные, <math>D</math> — правая двухдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрицы <math>Q, U</math> хранятся и используются не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием двух одномерных дополнительных массивов.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения разложения матрицы в произведение двухдиагональной и двух ортогональных используются попеременные умножения слева и справа её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

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

На каждом из шагов метода матрицы отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится для левых матриц отражения через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

Аналогично для правых матриц отражений <math>U=E-\frac{1}{\gamma}vv^*</math> <math>v</math> находится через координаты текущей <math>i</math>-й строки так:

<math>s</math> - вектор размерности <math>n-i</math>, составленный из элементов <math>i</math>-й строки, начиная с <math>i+1</math>-го элемента.

Если <math>(s,s)=0</math>, то <math>v=e_{i+1}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i+1</math>, <math>v_{j}=u_{j-i+2}</math> при <math>j>i+1</math>, а <math>v_{i+1}=1</math>, если <math>u_{1}=0</math> и <math>v_{i+1}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i+1}|</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>, и затем вычисления на каждом шагу (кроме шага с номером <math>i=n-1</math>) скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстрок <math>x</math> снизу от текущей, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

Всё приведение состоит из <math>2n-3</math> полушагов. Каждый из них состоит из вычисления некоторой матрицы отражений (Хаусхолдера) и умножения на неё матрицы. Строгая последовательность выполнения этих частей полушагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца, заканчивая <math>(n-1)</math>-м, попеременно с последовательным "обнулением" наддиагональных (кроме первой кодиагонали) элементов строк, начиная с 1й строки и заканчивая <math>(n-2)</math>-й

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i-1}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{2i-1}</math> на текущую версию матрицы.

В каждой "обнуляемой" <math>i</math>-й строке "обнуляются" сразу все его наддиагональные элементы одновременно, с <math>(i+2)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-й строки состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i}</math> такой, чтобы при умножении на неё справа "обнулились" все (кроме первого) наддиагональные её элементы;
б) умножение справа матрицы отражения <math>U_{2i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>4n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф нечётного полушага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего полушага), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего и жёлтых кружков - выходные для алгоритма.]]

На рисунке 1 изображён граф нечётного (<math>(2i-1)</math>го) полушага в привязке к элементам обрабатываемой матрицы. Граф чётного (<math>2i</math>го) полушага почти аналогичен, только длина ветвей (нарисована слева) будет меньше на 1 (<math>n-i</math>), и для привязки к элементам матрицы его надо отразить относительно диагонали матрицы. После этого отражения графы полушагов можно положить друг на друга слоями, при этом правые нижние углы должны быть друг над другом.

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций. Вычисления при "обнулении" <math>i</math>-й строки параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i-1</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''.

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Объём выходных данных''': <math>n^2+2n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной вещественной матрицы к двудиагональной форме на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2
DO K = I+1, N
SX(K)=2
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

IF (I.LT.N-1) THEN

DO K = I, N
SL(K)=A(I,N)*A(K,N)
END DO
DO J = N-1, I+1, -1
DO K = I, N
SL(K)=SL(K)+A(I,J)*A(K,J)
END DO
END DO

ALPHA = SQRT (SL(I))
IF (A(I,I+1).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = A(I,I+1)*BETA+SIGN(1.,A(I,I+1))
A(I,I+1)=ALPHA
G=1./ABS(SL(I)) ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SX(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = -1.
A(I,I+1)=ALPHA
G=1. ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SL(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
SL(I)=1
G=2.
DO K = I+1, N
SL(K)=2.
A(K,I+1) = A(K,I+1)-SL(K)
END DO
END IF
END IF

END IF
END DO
</source>

В этом варианте D расположена в диагонали и верхней кодиагонали массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов или надддиагональных - строк, а их первые элементы - в элементах массивов SX и SL.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qdu_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме. Общий профиль обращений в память]]

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

На рис. 3 показаны обращения в рамках первой итерации общего профиля (выделена на рис. 2 зеленым). Эти обращения можно условно разбить на несколько фрагментов. Фрагменты 1, 2 и 6 практически идентичны (различие заключается только в перестановке местами двух частей этих фрагментов), рассмотрим один из них.

[[file:householder_qdu_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

На рис. 4 показан отдельно фрагмент 6, выделенный на рис. 3. Теперь можно определить структуру каждой из двух частей более точно. Первая часть представляет собой последовательный перебор элементов в обратном порядке, причем к каждому элементу выполняется несколько обращений подряд. Во второй части также наблюдается последовательный перебор, однако с другими свойствами: элементы перебираются в прямом порядке, к каждому элементу выполняется только 1 обращение, однако данный перебор повторяется несколько раз подряд, причем каждый раз задействованы одни и те же элементы. Все это позволяет говорить о высокой пространственной локальности фрагмента (поскольку шаг по памяти каждый раз небольшой) и достаточно высокой временной локальности (поскольку данные часто используются повторно).

[[file:householder_qdu_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 6]]

Свойства локальности во фрагментах 3 и 5 можно оценить и без более детального рассмотрения. Данные в обоих фрагментах перебираются с достаточно большим шагом по памяти, при этом повторно они почти не используются, что говорит о низкой локальности в обоих случаях (хотя надо отметить, что локальность фрагмента 5 немного выше из-за более высокой пространственной локальности).

Теперь перейдем к рассмотрению фрагмента 4, расположенного в центре рис. 3. Поскольку он обладает регулярной структурой, достаточно более детально изучить небольшой фрагмент (представлен на рис. 5, выделен на рис. 3 зеленым). Здесь можно увидеть, что первая часть фрагмента представляет собой практически стандартный последовательный перебор (с небольшими нечастыми сдвигами, которые не влияют на локальность). Такой набор обращений обладает высокой пространственной и низкой временной локальностью. Вторая часть данного фрагмента устроена несколько сложнее – она состоит из L-образных наборов обращений. Одна его область (часть 1 на рис. 5) по строению очень похожа на первую часть; вторая (часть 2 на рис. 5) представляет собой набор обращений к одному и тому же элементу, что достаточно сильно повышает локальность данного фрагмента. Из этого можно сделать вывод, что фрагмент 4 обладает высокой пространственной и средней временной локальностью.

[[file:householder_qdu_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмент 4]]

Суммируя выше сказанное, можно сказать, что фрагменты 1, 2 и 6 обладают высокой локальностью; фрагменты 3 и 5 – низкой локальностью; фрагмент 4 – высокой пространственной и средней временной локальностью. Можно предположить, что в итоге локальность общего профиля будет не очень высокой, в основном из-за более низкой временной локальности. Однако такое достаточно сложное строение общего профиля затрудняет оценку локальности общего профиля на основе визуального анализа.

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что оценка производительности в данном случае не очень высока, что подтверждает сделанные ранее выводы. В частности, значение daps для этого примера показывает более низкую производительность по сравнению с реализациями других методов Хаусхолдера (householder_qr householder_qtq) и находится примерно на уровне оценки для реализации метода Холецкого.

[[file:householder_qdu_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:100] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 5.033e-05%;
* максимальная эффективность реализации 0.0135%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD perf2.png|thumb|center|700px|Рисунок 7. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD eff2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для приведения матриц к двудиагональному виду именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме

2017-01-06T14:17:30Z

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

{{algorithm
| name = Приведение матрицы к двудиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{8 n^3}{3}+O(n^2)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 2)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к двухдиагональному виду, или, что то же самое, для разложения <math>A=QDU^T</math> (<math>Q, U</math> - ортогональные, <math>D</math> — правая двухдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрицы <math>Q, U</math> хранятся и используются не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием двух одномерных дополнительных массивов.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения разложения матрицы в произведение двухдиагональной и двух ортогональных используются попеременные умножения слева и справа её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

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

На каждом из шагов метода матрицы отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится для левых матриц отражения через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

Аналогично для правых матриц отражений <math>U=E-\frac{1}{\gamma}vv^*</math> <math>v</math> находится через координаты текущей <math>i</math>-й строки так:

<math>s</math> - вектор размерности <math>n-i</math>, составленный из элементов <math>i</math>-й строки, начиная с <math>i+1</math>-го элемента.

Если <math>(s,s)=0</math>, то <math>v=e_{i+1}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i+1</math>, <math>v_{j}=u_{j-i+2}</math> при <math>j>i+1</math>, а <math>v_{i+1}=1</math>, если <math>u_{1}=0</math> и <math>v_{i+1}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i+1}|</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>, и затем вычисления на каждом шагу (кроме шага с номером <math>i=n-1</math>) скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстрок <math>x</math> снизу от текущей, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

Всё приведение состоит из <math>2n-3</math> полушагов. Каждый из них состоит из вычисления некоторой матрицы отражений (Хаусхолдера) и умножения на неё матрицы. Строгая последовательность выполнения этих частей полушагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца, заканчивая <math>(n-1)</math>-м, попеременно с последовательным "обнулением" наддиагональных (кроме первой кодиагонали) элементов строк, начиная с 1й строки и заканчивая <math>(n-2)</math>-й

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i-1}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{2i-1}</math> на текущую версию матрицы.

В каждой "обнуляемой" <math>i</math>-й строке "обнуляются" сразу все его наддиагональные элементы одновременно, с <math>(i+2)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-й строки состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i}</math> такой, чтобы при умножении на неё справа "обнулились" все (кроме первого) наддиагональные её элементы;
б) умножение справа матрицы отражения <math>U_{2i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>4n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф нечётного полушага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего полушага), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего и жёлтых кружков - выходные для алгоритма.]]

На рисунке 1 изображён граф нечётного (<math>(2i-1)</math>го) полушага в привязке к элементам обрабатываемой матрицы. Граф чётного (<math>2i</math>го) полушага почти аналогичен, только длина ветвей (нарисована слева) будет меньше на 1 (<math>n-i</math>), и для привязки к элементам матрицы его надо отразить относительно диагонали матрицы. После этого отражения графы полушагов можно положить друг на друга слоями, при этом правые нижние углы должны быть друг над другом.

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций. Вычисления при "обнулении" <math>i</math>-й строки параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i-1</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''.

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Объём выходных данных''': <math>n^2+2n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной вещественной матрицы к двудиагональной форме на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2
DO K = I+1, N
SX(K)=2
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

IF (I.LT.N-1) THEN

DO K = I, N
SL(K)=A(I,N)*A(K,N)
END DO
DO J = N-1, I+1, -1
DO K = I, N
SL(K)=SL(K)+A(I,J)*A(K,J)
END DO
END DO

ALPHA = SQRT (SL(I))
IF (A(I,I+1).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = A(I,I+1)*BETA+SIGN(1.,A(I,I+1))
A(I,I+1)=ALPHA
G=1./ABS(SL(I)) ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SX(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = -1.
A(I,I+1)=ALPHA
G=1. ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SL(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
SL(I)=1
G=2.
DO K = I+1, N
SL(K)=2.
A(K,I+1) = A(K,I+1)-SL(K)
END DO
END IF
END IF

END IF
END DO
</source>

В этом варианте D расположена в диагонали и верхней кодиагонали массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов или надддиагональных - строк, а их первые элементы - в элементах массивов SX и SL.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qdu_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме. Общий профиль обращений в память]]

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

На рис. 3 показаны обращения в рамках первой итерации общего профиля (выделена на рис. 2 зеленым). Эти обращения можно условно разбить на несколько фрагментов. Фрагменты 1, 2 и 6 практически идентичны (различие заключается только в перестановке местами двух частей этих фрагментов), рассмотрим один из них.

[[file:householder_qdu_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

На рис. 4 показан отдельно фрагмент 6, выделенный на рис. 3. Теперь можно определить структуру каждой из двух частей более точно. Первая часть представляет собой последовательный перебор элементов в обратном порядке, причем к каждому элементу выполняется несколько обращений подряд. Во второй части также наблюдается последовательный перебор, однако с другими свойствами: элементы перебираются в прямом порядке, к каждому элементу выполняется только 1 обращение, однако данный перебор повторяется несколько раз подряд, причем каждый раз задействованы одни и те же элементы. Все это позволяет говорить о высокой пространственной локальности фрагмента (поскольку шаг по памяти каждый раз небольшой) и достаточно высокой временной локальности (поскольку данные часто используются повторно).

[[file:householder_qdu_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 6]]

Свойства локальности во фрагментах 3 и 5 можно оценить и без более детального рассмотрения. Данные в обоих фрагментах перебираются с достаточно большим шагом по памяти, при этом повторно они почти не используются, что говорит о низкой локальности в обоих случаях (хотя надо отметить, что локальность фрагмента 5 немного выше из-за более высокой пространственной локальности).

Теперь перейдем к рассмотрению фрагмента 4, расположенного в центре рис. 3. Поскольку он обладает регулярной структурой, достаточно более детально изучить небольшой фрагмент (представлен на рис. 5, выделен на рис. 3 зеленым). Здесь можно увидеть, что первая часть фрагмента представляет собой практически стандартный последовательный перебор (с небольшими нечастыми сдвигами, которые не влияют на локальность). Такой набор обращений обладает высокой пространственной и низкой временной локальностью. Вторая часть данного фрагмента устроена несколько сложнее – она состоит из L-образных наборов обращений. Одна его область (часть 1 на рис. 5) по строению очень похожа на первую часть; вторая (часть 2 на рис. 5) представляет собой набор обращений к одному и тому же элементу, что достаточно сильно повышает локальность данного фрагмента. Из этого можно сделать вывод, что фрагмент 4 обладает высокой пространственной и средней временной локальностью.

[[file:householder_qdu_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмент 4]]

Суммируя выше сказанное, можно сказать, что фрагменты 1, 2 и 6 обладают высокой локальностью; фрагменты 3 и 5 – низкой локальностью; фрагмент 4 – высокой пространственной и средней временной локальностью. Можно предположить, что в итоге локальность общего профиля будет не очень высокой, в основном из-за более низкой временной локальности. Однако такое достаточно сложное строение общего профиля затрудняет оценку локальности общего профиля на основе визуального анализа.

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что оценка производительности в данном случае не очень высока, что подтверждает сделанные ранее выводы. В частности, значение daps для этого примера показывает более низкую производительность по сравнению с реализациями других методов Хаусхолдера (householder_qr householder_qtq) и находится примерно на уровне оценки для реализации метода Холецкого.

[[file:householder_qdu_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD perf2.png|thumb|center|700px|Рисунок 7. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD eff2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для приведения матриц к двудиагональному виду именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме

2017-01-06T14:16:59Z

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

{{algorithm
| name = Приведение матрицы к двудиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{8 n^3}{3}+O(n^2)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 2)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к двухдиагональному виду, или, что то же самое, для разложения <math>A=QDU^T</math> (<math>Q, U</math> - ортогональные, <math>D</math> — правая двухдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрицы <math>Q, U</math> хранятся и используются не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием двух одномерных дополнительных массивов.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения разложения матрицы в произведение двухдиагональной и двух ортогональных используются попеременные умножения слева и справа её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

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

На каждом из шагов метода матрицы отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится для левых матриц отражения через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

Аналогично для правых матриц отражений <math>U=E-\frac{1}{\gamma}vv^*</math> <math>v</math> находится через координаты текущей <math>i</math>-й строки так:

<math>s</math> - вектор размерности <math>n-i</math>, составленный из элементов <math>i</math>-й строки, начиная с <math>i+1</math>-го элемента.

Если <math>(s,s)=0</math>, то <math>v=e_{i+1}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i+1</math>, <math>v_{j}=u_{j-i+2}</math> при <math>j>i+1</math>, а <math>v_{i+1}=1</math>, если <math>u_{1}=0</math> и <math>v_{i+1}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i+1}|</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>, и затем вычисления на каждом шагу (кроме шага с номером <math>i=n-1</math>) скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстрок <math>x</math> снизу от текущей, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

Всё приведение состоит из <math>2n-3</math> полушагов. Каждый из них состоит из вычисления некоторой матрицы отражений (Хаусхолдера) и умножения на неё матрицы. Строгая последовательность выполнения этих частей полушагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца, заканчивая <math>(n-1)</math>-м, попеременно с последовательным "обнулением" наддиагональных (кроме первой кодиагонали) элементов строк, начиная с 1й строки и заканчивая <math>(n-2)</math>-й

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i-1}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{2i-1}</math> на текущую версию матрицы.

В каждой "обнуляемой" <math>i</math>-й строке "обнуляются" сразу все его наддиагональные элементы одновременно, с <math>(i+2)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-й строки состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i}</math> такой, чтобы при умножении на неё справа "обнулились" все (кроме первого) наддиагональные её элементы;
б) умножение справа матрицы отражения <math>U_{2i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>4n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф нечётного полушага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего полушага), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего и жёлтых кружков - выходные для алгоритма.]]

На рисунке 1 изображён граф нечётного (<math>(2i-1)</math>го) полушага в привязке к элементам обрабатываемой матрицы. Граф чётного (<math>2i</math>го) полушага почти аналогичен, только длина ветвей (нарисована слева) будет меньше на 1 (<math>n-i</math>), и для привязки к элементам матрицы его надо отразить относительно диагонали матрицы. После этого отражения графы полушагов можно положить друг на друга слоями, при этом правые нижние углы должны быть друг над другом.

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций. Вычисления при "обнулении" <math>i</math>-й строки параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i-1</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''.

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Объём выходных данных''': <math>n^2+2n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной вещественной матрицы к двудиагональной форме на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2
DO K = I+1, N
SX(K)=2
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

IF (I.LT.N-1) THEN

DO K = I, N
SL(K)=A(I,N)*A(K,N)
END DO
DO J = N-1, I+1, -1
DO K = I, N
SL(K)=SL(K)+A(I,J)*A(K,J)
END DO
END DO

ALPHA = SQRT (SL(I))
IF (A(I,I+1).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = A(I,I+1)*BETA+SIGN(1.,A(I,I+1))
A(I,I+1)=ALPHA
G=1./ABS(SL(I)) ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SX(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = -1.
A(I,I+1)=ALPHA
G=1. ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SL(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
SL(I)=1
G=2.
DO K = I+1, N
SL(K)=2.
A(K,I+1) = A(K,I+1)-SL(K)
END DO
END IF
END IF

END IF
END DO
</source>

В этом варианте D расположена в диагонали и верхней кодиагонали массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов или надддиагональных - строк, а их первые элементы - в элементах массивов SX и SL.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qdu_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме. Общий профиль обращений в память]]

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

На рис. 3 показаны обращения в рамках первой итерации общего профиля (выделена на рис. 2 зеленым). Эти обращения можно условно разбить на несколько фрагментов. Фрагменты 1, 2 и 6 практически идентичны (различие заключается только в перестановке местами двух частей этих фрагментов), рассмотрим один из них.

[[file:householder_qdu_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

На рис. 4 показан отдельно фрагмент 6, выделенный на рис. 3. Теперь можно определить структуру каждой из двух частей более точно. Первая часть представляет собой последовательный перебор элементов в обратном порядке, причем к каждому элементу выполняется несколько обращений подряд. Во второй части также наблюдается последовательный перебор, однако с другими свойствами: элементы перебираются в прямом порядке, к каждому элементу выполняется только 1 обращение, однако данный перебор повторяется несколько раз подряд, причем каждый раз задействованы одни и те же элементы. Все это позволяет говорить о высокой пространственной локальности фрагмента (поскольку шаг по памяти каждый раз небольшой) и достаточно высокой временной локальности (поскольку данные часто используются повторно).

[[file:householder_qdu_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 6]]

Свойства локальности во фрагментах 3 и 5 можно оценить и без более детального рассмотрения. Данные в обоих фрагментах перебираются с достаточно большим шагом по памяти, при этом повторно они почти не используются, что говорит о низкой локальности в обоих случаях (хотя надо отметить, что локальность фрагмента 5 немного выше из-за более высокой пространственной локальности).

Теперь перейдем к рассмотрению фрагмента 4, расположенного в центре рис. 3. Поскольку он обладает регулярной структурой, достаточно более детально изучить небольшой фрагмент (представлен на рис. 5, выделен на рис. 3 зеленым). Здесь можно увидеть, что первая часть фрагмента представляет собой практически стандартный последовательный перебор (с небольшими нечастыми сдвигами, которые не влияют на локальность). Такой набор обращений обладает высокой пространственной и низкой временной локальностью. Вторая часть данного фрагмента устроена несколько сложнее – она состоит из L-образных наборов обращений. Одна его область (часть 1 на рис. 5) по строению очень похожа на первую часть; вторая (часть 2 на рис. 5) представляет собой набор обращений к одному и тому же элементу, что достаточно сильно повышает локальность данного фрагмента. Из этого можно сделать вывод, что фрагмент 4 обладает высокой пространственной и средней временной локальностью.

[[file:householder_qdu_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмент 4]]

Суммируя выше сказанное, можно сказать, что фрагменты 1, 2 и 6 обладают высокой локальностью; фрагменты 3 и 5 – низкой локальностью; фрагмент 4 – высокой пространственной и средней временной локальностью. Можно предположить, что в итоге локальность общего профиля будет не очень высокой, в основном из-за более низкой временной локальности. Однако такое достаточно сложное строение общего профиля затрудняет оценку локальности общего профиля на основе визуального анализа.

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что оценка производительности в данном случае не очень высока, что подтверждает сделанные ранее выводы. В частности, значение daps для этого примера показывает более низкую производительность по сравнению с реализациями других методов Хаусхолдера (householder_qr householder_qtq) и находится примерно на уровне оценки для реализации метода Холецкого.

[[file:householder_qdu_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для приведения матриц к двудиагональному виду именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-28T12:47:29Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:81] с шагом n^2;
* размер матрицы [1000 : 16000] с шагом 1000.

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

* минимальная эффективность реализации 4.763e-05%;
* максимальная эффективность реализации 0.011%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD Perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSYTRD eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-28T12:44:57Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 4.073e-06%;
* максимальная эффективность реализации 0.0667%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD Perf2.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSYTRD eff2.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-19T12:42:25Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 4.073e-06%;
* максимальная эффективность реализации 0.0667%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSETRD EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-19T12:41:38Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 4.073e-06%;
* максимальная эффективность реализации 0.0667%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDSYTRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDSYTRD PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDSYTRD EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-18T10:30:32Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

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

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме

2016-12-18T10:30:18Z

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

{{algorithm
| name = Приведение матрицы к двудиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{8 n^3}{3}+O(n^2)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 2)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к двухдиагональному виду, или, что то же самое, для разложения <math>A=QDU^T</math> (<math>Q, U</math> - ортогональные, <math>D</math> — правая двухдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрицы <math>Q, U</math> хранятся и используются не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием двух одномерных дополнительных массивов.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения разложения матрицы в произведение двухдиагональной и двух ортогональных используются попеременные умножения слева и справа её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

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

На каждом из шагов метода матрицы отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится для левых матриц отражения через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

Аналогично для правых матриц отражений <math>U=E-\frac{1}{\gamma}vv^*</math> <math>v</math> находится через координаты текущей <math>i</math>-й строки так:

<math>s</math> - вектор размерности <math>n-i</math>, составленный из элементов <math>i</math>-й строки, начиная с <math>i+1</math>-го элемента.

Если <math>(s,s)=0</math>, то <math>v=e_{i+1}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i+1</math>, <math>v_{j}=u_{j-i+2}</math> при <math>j>i+1</math>, а <math>v_{i+1}=1</math>, если <math>u_{1}=0</math> и <math>v_{i+1}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i+1}|</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>, и затем вычисления на каждом шагу (кроме шага с номером <math>i=n-1</math>) скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстрок <math>x</math> снизу от текущей, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

Всё приведение состоит из <math>2n-3</math> полушагов. Каждый из них состоит из вычисления некоторой матрицы отражений (Хаусхолдера) и умножения на неё матрицы. Строгая последовательность выполнения этих частей полушагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца, заканчивая <math>(n-1)</math>-м, попеременно с последовательным "обнулением" наддиагональных (кроме первой кодиагонали) элементов строк, начиная с 1й строки и заканчивая <math>(n-2)</math>-й

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i-1}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{2i-1}</math> на текущую версию матрицы.

В каждой "обнуляемой" <math>i</math>-й строке "обнуляются" сразу все его наддиагональные элементы одновременно, с <math>(i+2)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-й строки состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{2i}</math> такой, чтобы при умножении на неё справа "обнулились" все (кроме первого) наддиагональные её элементы;
б) умножение справа матрицы отражения <math>U_{2i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>4n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф нечётного полушага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего полушага), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего и жёлтых кружков - выходные для алгоритма.]]

На рисунке 1 изображён граф нечётного (<math>(2i-1)</math>го) полушага в привязке к элементам обрабатываемой матрицы. Граф чётного (<math>2i</math>го) полушага почти аналогичен, только длина ветвей (нарисована слева) будет меньше на 1 (<math>n-i</math>), и для привязки к элементам матрицы его надо отразить относительно диагонали матрицы. После этого отражения графы полушагов можно положить друг на друга слоями, при этом правые нижние углы должны быть друг над другом.

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций. Вычисления при "обнулении" <math>i</math>-й строки параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i-1</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''.

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Объём выходных данных''': <math>n^2+2n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной вещественной матрицы к двудиагональной форме на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2
DO K = I+1, N
SX(K)=2
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

IF (I.LT.N-1) THEN

DO K = I, N
SL(K)=A(I,N)*A(K,N)
END DO
DO J = N-1, I+1, -1
DO K = I, N
SL(K)=SL(K)+A(I,J)*A(K,J)
END DO
END DO

ALPHA = SQRT (SL(I))
IF (A(I,I+1).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = A(I,I+1)*BETA+SIGN(1.,A(I,I+1))
A(I,I+1)=ALPHA
G=1./ABS(SL(I)) ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SX(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(I,J)=A(I,J)*BETA
END DO
SL(I) = -1.
A(I,I+1)=ALPHA
G=1. ! 1/gamma
DO K = I+1, N
SL(K)=SL(K)*BETA*G+SIGN(A(K,I+1),SL(I))
A(K,I+1) = A(K,I+1)+SL(K)*SL(I)
DO J = I+2, N
A (K,J) = A(K,J)-A(I,J)*SL(K)
END DO
END DO
ELSE
SL(I)=1
G=2.
DO K = I+1, N
SL(K)=2.
A(K,I+1) = A(K,I+1)-SL(K)
END DO
END IF
END IF

END IF
END DO
</source>

В этом варианте D расположена в диагонали и верхней кодиагонали массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов или надддиагональных - строк, а их первые элементы - в элементах массивов SX и SL.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qdu_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме. Общий профиль обращений в память]]

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

На рис. 3 показаны обращения в рамках первой итерации общего профиля (выделена на рис. 2 зеленым). Эти обращения можно условно разбить на несколько фрагментов. Фрагменты 1, 2 и 6 практически идентичны (различие заключается только в перестановке местами двух частей этих фрагментов), рассмотрим один из них.

[[file:householder_qdu_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

На рис. 4 показан отдельно фрагмент 6, выделенный на рис. 3. Теперь можно определить структуру каждой из двух частей более точно. Первая часть представляет собой последовательный перебор элементов в обратном порядке, причем к каждому элементу выполняется несколько обращений подряд. Во второй части также наблюдается последовательный перебор, однако с другими свойствами: элементы перебираются в прямом порядке, к каждому элементу выполняется только 1 обращение, однако данный перебор повторяется несколько раз подряд, причем каждый раз задействованы одни и те же элементы. Все это позволяет говорить о высокой пространственной локальности фрагмента (поскольку шаг по памяти каждый раз небольшой) и достаточно высокой временной локальности (поскольку данные часто используются повторно).

[[file:householder_qdu_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 6]]

Свойства локальности во фрагментах 3 и 5 можно оценить и без более детального рассмотрения. Данные в обоих фрагментах перебираются с достаточно большим шагом по памяти, при этом повторно они почти не используются, что говорит о низкой локальности в обоих случаях (хотя надо отметить, что локальность фрагмента 5 немного выше из-за более высокой пространственной локальности).

Теперь перейдем к рассмотрению фрагмента 4, расположенного в центре рис. 3. Поскольку он обладает регулярной структурой, достаточно более детально изучить небольшой фрагмент (представлен на рис. 5, выделен на рис. 3 зеленым). Здесь можно увидеть, что первая часть фрагмента представляет собой практически стандартный последовательный перебор (с небольшими нечастыми сдвигами, которые не влияют на локальность). Такой набор обращений обладает высокой пространственной и низкой временной локальностью. Вторая часть данного фрагмента устроена несколько сложнее – она состоит из L-образных наборов обращений. Одна его область (часть 1 на рис. 5) по строению очень похожа на первую часть; вторая (часть 2 на рис. 5) представляет собой набор обращений к одному и тому же элементу, что достаточно сильно повышает локальность данного фрагмента. Из этого можно сделать вывод, что фрагмент 4 обладает высокой пространственной и средней временной локальностью.

[[file:householder_qdu_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмент 4]]

Суммируя выше сказанное, можно сказать, что фрагменты 1, 2 и 6 обладают высокой локальностью; фрагменты 3 и 5 – низкой локальностью; фрагмент 4 – высокой пространственной и средней временной локальностью. Можно предположить, что в итоге локальность общего профиля будет не очень высокой, в основном из-за более низкой временной локальности. Однако такое достаточно сложное строение общего профиля затрудняет оценку локальности общего профиля на основе визуального анализа.

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что оценка производительности в данном случае не очень высока, что подтверждает сделанные ранее выводы. В частности, значение daps для этого примера показывает более низкую производительность по сравнению с реализациями других методов Хаусхолдера (householder_qr householder_qtq) и находится примерно на уровне оценки для реализации метода Холецкого.

[[file:householder_qdu_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера для приведения матриц к двухдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для приведения матриц к двудиагональному виду именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Итерация алгоритма dqds

2016-12-18T10:26:18Z

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

{{algorithm
| name = Алгоритм dqds нахождения сингулярных чисел двухдиагональной матрицы
| serial_complexity = <math>5n-4</math>
| pf_height = <math>4n-3</math>
| pf_width = <math>2</math>
| input_data = <math>2n</math>
| output_data = <math>2n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]]

== Свойства и структура алгоритмов ==
=== Общее описание алгоритма ===

'''Итерация алгоритма dqds''' является одним шагом алгоритма dqds нахождения сингулярных чисел двухдиагональной матрицы.

Сам алгоритм '''dqds''' (''differential quotient-difference algorithm with shifts'')<ref name="vla">Деммель Д. Вычислительная линейная алгебра. – М : Мир, 2001.</ref><ref name="hola">Hogben L. (ed.). Handbook of linear algebra. – CRC Press, 2006.</ref> строит последовательность двухдиагональных матриц, сходящуюся к диагональной матрице, содержащей квадраты искомых сингулярных чисел. Его особенностью является высокая точность решения задачи.
Вычислительным ядром алгоритма является именно внутренняя итерация, вне итераций происходит подбор сдвига <math>\delta</math> (параметер итерации, см. [[#Математическое описание алгоритма|математическое описание алгоритма]]), отслеживание сходимости, а также применение различных оптимизационных "хитростей". Отметим, что внеитерационная часть алгоритма не существенна с точки зрения структуры вычислений, т.к. основные затраты ложатся на вычисления внутри итерации. Подробности и варианты внеитерационной части, а также анализ сходимости можно найти в соответствующей литературе
<ref>Fernando K. V., Parlett B. N. Accurate singular values and differential qd algorithms //Numerische Mathematik. – 1994. – Т. 67. – №. 2. – С. 191-229.</ref>
<ref>Parlett B. N., Marques O. A. An implementation of the dqds algorithm (positive case) //Linear Algebra and its Applications. – 2000. – Т. 309. – №. 1. – С. 217-259.</ref>
<ref>Aishima K. et al. On convergence of the DQDS algorithm for singular value computation //SIAM Journal on Matrix Analysis and Applications. – 2008. – Т. 30. – №. 2. – С. 522-537.</ref>.

=== Математическое описание алгоритма ===

==== Вспомогательные сведения ====
Для понимания математических основ dqds-итерации полезно рассмотреть кратко её вывод, частично отражающий и историю возникновения алгоритма (подробности можно найти в <ref name="vla"/>).
За основу dqds-алгоритма удобно взять так называемую LR-итерацию, предшествующую хорошо-известной QR-итерации. LR-алгоритм, начиная с входной матрицы <math>T_0>0,</math> строит сходящуюся последовательность подобных <math>T_0</math> матриц <math>T_i>0,</math> итерационно используя следующие три шага:
#Выбрать сдвиг <math>\tau_i</math> меньший младшего собственного значения <math>T_i.</math>
#Вычислить разложение Холецкого <math>T_i-\tau^2_iI=B_i^TB_i,</math> где <math>B_i</math> - верхняя треугольная матрица с положительной диагональю.
#<math>T_{i+1}=B_iB_i^T+\tau_i^2I.</math>

Отметим, что два шага LR-итерации с нулевым сдвигом эквивалентны одному шагу QR-итерации. Итерационная процедура приводит матрицу к диагональному виду, тем самым вычисляя собственные значения исходной матрицы. LR-алгоритм достаточно легко может быть переформулирован с заметными упрощениями для задачи поиска сингулярных значений двухдиагональных матриц. А именно, будем вычислять последовательность двухдиагональных матриц <math>B_i</math> без непосредственного вычисления <math>T_i</math>(которые в данном случае будут трехдиагональными). Пусть матрица <math>B_i</math> имеет диагональные элементы <math>a_1 \ldots a_n</math> и наддиагональные элементы <math>b_1 \ldots b_{n-1}</math>, а матрица <math>B_{i+1}</math> - диагональные элементы <math>\widehat{a}_1 \ldots \widehat{a}_n</math> и наддиагональные элементы <math>\widehat{b}_1 \ldots \widehat{b}_{n-1}.</math> Тогда шаг LR-итерации в терминах матриц <math>B_i</math> можно привести к простому циклу, пробегающему значения <math>j</math> от <math>1</math> до <math>n-1:</math>

:<math>
\widehat{a}^2_j = a^2_j+b^2_j-\widehat{b}^2_{j-1}-\delta
</math>
:<math>
\widehat{b}^2_j = b^2_j\dot (a^2_{j+1}/a^2_j)
</math>
и вычислению <math>\widehat{a}^2_n = a^2_n-\widehat{b}^2_{n-1}-\delta.</math> Очевидно, что работу с извлечением квадратов выгодно вести лишь после окончания работы алгоритма, поэтому можно ввести замену <math>q_j=a^2_j,\; e_j=b^2,</math> что в итоге приводит к так называемому алгоритму qds.
Формулы алгоритма следующие:

:<math>
\widehat{q}_j = q_j + e_j - \widehat{e}_{j-1} - \delta, \quad j \in [1,n-1]
</math>
:<math>
\widehat{e}_j = e_j \cdot q_{j+1} / \widehat{q}_j, \quad j \in [1,n-1]
</math>
:<math>
\widehat{q}_n = q_n - \widehat{e}_{n-1} - \delta.
</math>

Здесь <math>q_j, \; j \in [1,n]</math> и <math>e_j, \; j \in [1,n-1]</math> - квадраты элемнтов главной и верхней побочной диагонали соответственно. Крышка означает выходные переменные, а

<math>\delta</math> - сдвиг (параметр алгоритма).
Такая математическая запись наиболее компактна и соответствует так называемой qds-итерации.

==== Математическое описание итерации алгоритма dqds====
Представим теперь математическую запись, приближенную к dqds-итерации (с математической точки зрения qds и dqds-итерации эквивалентны) с введенными вспомогательными переменными

<math>t_j</math> и <math>d_j.</math> Итерация алгоритма dqds преобразует входную двухдиагональную матрицу <math>B</math> в выходную <math>\widehat{B}.</math>

Входные и выходные данные: <math>q_{j}, \; j\in [1,n], \; e_{k}, \; k\in [1,n-1] </math> - квадраты элементов главной и побочной диагонали входной матрицы <math>B</math>, <math> \widehat{q}_j , \; \widehat{e}_k </math> - то же для вычисляемой матрицы <math>\widehat{B}.</math>.

Формулы метода выглядят следующим образом:

:<math>
d_1 = q_1 - \delta, \; q_n = d_n
</math>
:для<math>
\quad j\in [1,n-1]:
</math>
:<math>
\widehat{q}_j = d_j + e_j
</math>
:<math>
t_j = q_{j+1}/\widehat{q}_j
</math>
:<math>
\widehat{e}_j=e_j \cdot t_j
</math>
:<math>
d_{j+1} = d \cdot t - \delta
</math>

=== Вычислительное ядро алгоритма ===

Вычислительным ядром алгоритма является последовательный расчёт квадратов диагональных (<math>\widehat{q}_j</math>) и внедиагональных (<math>\widehat{e}_k</math>) элементов выходной матрицы. Учитывая использование вспомогательных переменных расчёт каждой новой пары содержит по одной операции сложения, вычитания и деления, а также две операции умножения.

=== Макроструктура алгоритма ===

Алгоритм состоит из отдельного вычисления начального значения вспомогательной переменной <math>d,</math> последующим (n-1)-кратным выполнением повторяющейся последовательности из 5 операций (+,/,*,*,-) для вычисления квадратов диагональных (<math>\widehat{q}_j</math>) и внедиагональных (<math>\widehat{e}_k</math>) элементов выходной матрицы и завершающего вычислением крайнего значения <math>\widehat{q}_n</math>.

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

Отметим, что выходные данные сразу могут быть записаны на место входных (это учтено в схеме), также для хранения вспомогательных переменных <math>t_j</math> и <math>d_j</math> достаточно двух перезаписываемых переменных. Таким образом элементы главной (<math>q_j</math>) и побочной (<math>e_k</math>) диагонали входной матрицы последовательно перезаписываются соответствующими элементами выходной матрицы.

Последовательность исполнения метода следующая:

1. Вычисляется начальное значение вспомогательной переменной <math>d = q_1-\delta.</math>

2. Производится цикл по j от 1 до n-1, состоящий из:

:2.1 Вычисляется значение <math>q_j = d + e_j;</math>
:2.2 Вычисляется значение вспомогательной переменной <math>t = q_{j+1}/q_j;</math>
:2.3 Вычисляется значение <math>e_j = e_j \cdot t;</math>
:2.4 Вычисляется значение вспомогательной переменной <math>d = d \cdot t - \delta.</math>
:

3. Вычисляется <math>q_n = d.</math>

Легко заметить, что можно представить вычисления в другой форме, например, в виде qds-итерации (см. [[Итерация алгоритма dqds#Математическое описание алгоритма|Математическое описание dqds-итерации]]), однако, именно dqds реализация вычисления позволяет достичь высокой точности<ref name="vla"></ref>.

=== Последовательная сложность алгоритма ===

Для выполнения одной итерации dqds необходимо выполнить:

* <math>n-1</math> делений,
* <math>2n-2</math> умножений,
* <math>2n-1</math> сложений/вычитаний.

Таким образом одна dqds-итерация имеет ''линейную сложность''.

=== Информационный граф ===
[[file:dqds.png|thumb|center|600px|Рисунок 1. Граф алгоритма для n=4 без отображения входных и выходных данных.]]

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

Как видно из информационного графа алгоритма, на каждом шаге основного цикла возможно лишь параллельное выполнение операции умножения (2.2) и умножения+сложения (2.4). Это позволяет сократить число ярусов на одной итерации цикла c 5 до 4, а общее число ярусов алгоритма с 5n-4 до 4n-3. Ярусы с операциями умножения состоят из двух операций, остальные же из одной.

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

'''Входные данные''': Квадраты элементов основной и верхней побочной диагонали двухдиагональной матрицы (вектора <math>q</math> длины n и <math>e</math> длины n-1), а также параметр сдвига <math>\delta</math>.

'''Объём входных данных''': <math>2n</math>.

'''Выходные данные''': Квадраты элементов основной и верхней побочной диагонали выходной двухдиагональной матрицы.

'''Объём выходных данных''': <math>2n-1</math>.

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

Соотношение последовательной и параллельной сложности при наличии возможности параллельного выполнения операций умножения составляет <math>\frac{5n-4}{4n-3}</math>, т.е. алгоритм плохо распараллеливается.

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

Описываемый алгоритм является полностью детерминированным.

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

Алгоритм на языке Matlab может быть записать так:
<source lang="matlab">

d = q(1)-delta;
for j = 1:n-1
q(j)=d+e(j);
t=q(j+1)/q(j);
e(j) = e(j)*t;
d = d*t-delta;
end
q(n) = d;

</source>

Как говорилось в [[#Схема реализации последовательного алгоритма|cхеме реализации последовательного алгоритма]], вычисляемые данные записываются сразу на место входных.

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

Легко видеть, что локальность данных высока. Её легко повысить, размещая рядом соответствующие элементы массивов e и q, однако, это не оказывает существенного влияния на производительность в силу константного количества операций относительно объема обрабатываемых данных.

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

[[file:dqds_1.png|thumb|center|700px|Рисунок 2. Итерация алгоритма dqds. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации итерации алгоритма dqds. Данный профиль внешне устроен очень просто и состоит из двух параллельно выполняемых последовательных переборов. Отметим, что общее число обращений в память всего в 3 раза больше числа задействованных данных, что говорит о том, что данные повторно используют редко. Зачастую это сигнализирует о достаточно невысокой локальности.

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

Поскольку данная структура обращений и составляет общий профиль, то же самое можно говорить и о локальности всего профиля.

[[file:dqds_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

===== Количественная оценка локальности =====
Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

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

[[file:dqds_daps.png|thumb|center|700px|Рисунок 4. Сравнение значений оценки daps]]

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

Итерация dqds практически полностью последовательна. Единственная возможность - одновременное выполнение операции умножения (2.3) и операции (2.4) умножения и сложения, что дает небольшой выигрыш в производительности.

=== Масштабируемость алгоритма и его реализации ===

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

Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров 1;
* размер матрицы [1000 : 260000] с шагом 500.

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

* минимальная эффективность реализации 2.559e-06%;
* максимальная эффективность реализации 2.492e-08%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации DQDS в зависимости от изменяемых параметров запуска.

[[file:DQDS Perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма dqds. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:DQDS eff.png|thumb|center|700px|Рисунок 9. Параллельная реализация алгоритма dqds. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

[http://git.algowiki-project.org/Teplov/Scalability/tree/master/DQDS/dqds.c Исследованная параллельная реализация на языке C]

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

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

=== Существующие реализации алгоритма ===
Сам алгоритм dqds реализован в функции xBDSQR пакета LAPACK и используется при её вызове без расчёта сингулярных векторов.

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

<references />

[[Категория:Статьи в работе]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2016-12-18T10:18:40Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера QR-разложения. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-18T10:14:57Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEHRD из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEHRD PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация метода Хаусхолдера для приведения симметричных матриц к трехдиагональному виду. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEHRD EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация метода Хаусхолдера для приведения симметричных матриц к трехдиагональному виду. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант

2016-12-18T10:10:26Z

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

{{algorithm
| name = QR-разложение методом Хаусхолдера (отражений)
| serial_complexity = <math>\frac{4 n^3}{3}</math>
| pf_height = <math>n^2</math>
| pf_width = <math>n^2</math>
| input_data = <math>n^2</math>
| output_data = <math>n(n + 1)</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для разложения матриц в виде <math>A=QR</math> (<math>Q</math> - унитарная, <math>R</math> — правая треугольная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием минимального одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QR</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений).

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы в <math>i</math>-м столбце. Таким образом, после <math>n-1</math> шагов преобразований получается матрица <math>R</math> из <math>QR</math>-разложения.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma =1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>.

=== Вычислительное ядро алгоритма ===

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Это используется при программировании метода во многих библиотеках для его конструирования из стандартных подпрограмм (например, из BLAS).

=== Макроструктура алгоритма ===

[[File:HausLeft1.png|thumb|right|600px|Рисунок 1. Граф шага (обнуление <math>i</math>го столбца) алгоритма. Квадратики - входные данные шага (берутся с предыдущего или из входных данных), кружки - операции. Зелёным выделены операции типа a+bb, салатовым и голубым - типа a+bc, тёмно-синим - вычисление <math>\gamma , v_{1}</math>, жёлтым - умножения (или деления). Обведённая группа операций повторяется независимо n-i раз. Результаты синего, красных и жёлтых кружков, а на последнем шаге и голубого - выходные для алгоритма.]]

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также векторные операции <math>x'=x-\frac{(x,v)}{\gamma}v</math>. При этом, однако, строгая последовательность выполнения этих трёх подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них <math>(x,v)</math>. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) умножение слева матрицы отражения <math>U_{i}</math> на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также модификаций векторов вида <math>x'=x-\alpha v</math>, причем над векторами убывающей по ходу алгоритма размерности. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>2n^3/3</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в разложении матрицы порядка <math>n</math> методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>n-i</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>\frac{n^2}{2}</math> умножений и <math>\frac{n^2}{2}</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути; при таком расширении сложность по ширине ЯПФ станет ''линейной'').

Надо сказать, что здесь в оценках речь идёт именно о классическом способе реализации метода Хаусхолдера. Даже использование схем сдваивания или последовательно-параллельных для вычисления скалярных произведений уменьшает критический путь с квадратичного до ''степени 3/2'' или ''линейно-логарифмического''. Однако все эти широко распространённые методы пока не дали возможности снизить критический путь метода Хаусхолдера до ''линейного'' (как, скажем, у метода Гивенса).

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

'''Входные данные''': плотная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>n^2</math>.

'''Выходные данные''': правая треугольная матрица <math>R</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>n^2+n</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) QR-разложения квадратной вещественной матрицы на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-1
DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I, -1
DO K = I, N
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I,I)*BETA+SIGN(1.,A(I,I))
A(I,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+1, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I,I)=ALPHA
G=1.! 1/gamma
DO K = I+1, N
SX(K)=SX(K)*BETA*G+SIGN(A(I,K),SX(I))
A(I,K) = A(I,K)+SX(K)*SX(I)
DO J = I+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)
END DO
END DO
ELSE
SX(I)=1
G=2.
DO K = I+1, N
SX(K)=2.
A(I,K) = A(I,K)-SX(K)
END DO
END IF
END IF

END DO
</source>

В этом варианте R расположена в верхнем правом треугольнике массива A, направляющие вектора матриц отражений размещены в поддиагональных элементах соответствующих столбцов, а их первые элементы - в элементах массива SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qr_1.png|thumb|center|700px|Рисунок 2. Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант. Общий профиль обращений в память]]

На рис. 2 представлен профиль обращений в память для реализации вещественного варианта метода Хаусхолдера (отражений) QR-разложения квадратной матрицы. Из данного рисунка можно сделать несколько выводов. Во-первых, видно, что в среднем к каждому элементу выполняется примерно 90 обращений (отношение общего числа обращений к числу задействованных данных), что является достаточно хорошим показателем в плане повторного использования данных. Далее, явно видна итерационная структура профиля, причем на каждой следующей итерации обращения к небольшой части первых элементов перестают выполняться. Это говорит о том, что ближе к концу профиля задействовано меньше данных, что хорошо сказывается на пространственной локальности. Однако в то же время видно, что на каждой следующей итерации выполняется меньше обращений к одним и тем же локальным областям, то есть временная локальность, по всей вероятности, становится ниже. Рассмотрим подробнее первую итерацию, что более детально оценить их строение.

На рис. 3 представлена одна итерация общего профиля (выделенный зеленый фрагмент на рис. 2). Ее можно условно разбить на 5 фрагментов, каждую из которых рассмотреть отдельно. Фрагменты 2 и 5 устроены просто – элементы перебираются с большим шагом по памяти, при достижении конца данных перебор повторяется, только с небольшим сдвигом. Про такие фрагменты можно сказать, что они обладают низкой пространственной локальностью, поскольку шаг по памяти достаточно большой, и низкой временной локальностью, так как данные повторно не используются. Однако отметим, что данные фрагменты состоят из небольшого числа обращений, что означает, что они не так сильно будут снижать общую локальность профиля.

[[file:householder_qr_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, одна итерация]]

Далее, фрагмент 1 и 3 устроены практически идентично (основное отличие – два основных этапа переставлены местами), поэтому рассмотрим только один из них. На рис. 4 представлен фрагмент 3. Здесь хорошо видно, как устроены эти этапы. На первом этапе выполняется перебор элементов в обратном порядке с шагом 1, при этом к каждому элементу подряд обращаются несколько раз. Такой фрагмент обладает очень высокой пространственной локальностью и достаточно высокой временной локальностью.

[[file:householder_qr_3.png|thumb|center|500px|Рисунок 4. Профиль обращений, одна итерация, фрагмент 3]]

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

Далее рассмотрим фрагмент 4. Чтобы лучше понять локальную структуру, детально изучим небольшую его часть (рис. 5). Из данного рисунка хорошо видно, что здесь профиль устроен очень просто и представляет собой обычный последовательный перебор с шагом 1 (с небольшими и нечастыми сдвигами, которые не влияют на локальность этого фрагмента). Такой фрагмент обладает высокой пространственной, но низкой временной локальностью.

[[file:householder_qr_4.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, часть фрагмента 4]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 6 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном примере высока. Значение daps для него находится на одном уровне с тестом Linpack и лишь немногим ниже, чем, например, самые эффективные варианты перемножения плотных матриц. Это означает, что негативное влияние фрагментов 2 и 5 оказывается достаточно слабым, вероятно (как и предполагалось ранее) из-за небольшого их размера.

[[file:householder_qr_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация циклической редукции. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация циклической редукции. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-18T10:08:20Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации алгоритма в процедуре PDGEQRF из Scalapack в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация циклической редукции. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация циклической редукции. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду

2016-12-18T10:07:28Z

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

{{algorithm
| name = Приведение симметричной вещественной матрицы к трёхдиагональному виду методом Хаусхолдера (отражений)
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>2n^2+O(n)</math>
| pf_width = <math>n^2/2</math>
| input_data = <math>(n^2+n)/2</math>
| output_data = <math>(n^2+3n)/2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]]

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

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

'''Метод Хаусхолдера''' (в советской математической литературе чаще называется '''методом отражений''') используется для приведения симметричных вещественных матриц к трёхдиагональному виду, или, что то же самое, для разложения <math>A=QTQ^T</math> (<math>Q</math> - ортогональная, <math>T</math> — симметричная трёхдиагональная матрица)<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>. При этом матрица <math>Q</math> хранится и используется не в своём явном виде, а в виде произведения матриц отражения<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref>. Каждая из матриц отражения может быть определена одним вектором. Это позволяет в классическом исполнении метода отражений хранить результаты разложения на месте матрицы A с использованием одномерного дополнительного массива.

В данной статье рассматривается именно классическое исполнение, в котором не используются приёмы типа сдваивания при вычислениях скалярных произведений.

=== Математическое описание алгоритма ===

В методе Хаусхолдера для выполнения <math>QTQ^T</math>-разложения матрицы используются умножения слева её текущих модификаций на матрицы Хаусхолдера (отражений) с последующим умножением на те же матрицы справа.

{{Шаблон:Матрица отражений}}

На <math>i</math>-м шаге метода с помощью преобразования отражения "убираются" ненулевые поддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-м столбце. После умножения на эту же матрицу отражения справа автоматически убираются и ненулевые наддиагональные элементы, начиная с <math>i+2</math>-го в <math>i</math>-й строке, а полученная модификация снова приобретает симметричный вид.

На каждом из шагов метода матрицу отражений обычно представляют не в стандартном виде, а в виде <math>U=E-\frac{1}{\gamma}vv^*</math>, где <math>v</math> находится через координаты текущего <math>i</math>-го столбца так:

<math>s</math> - вектор размерности <math>n+1-i</math>, составленный из элементов <math>i</math>-го столбца, начиная с <math>i</math>-го.

Если <math>(s,s)=0</math>, то <math>v=e_{i}</math>, <math>\gamma = \frac{1}{2}</math>.

В остальных случаях по алгоритму вычисляется <math>u = \frac{1}{\sqrt{(s,s)}}s</math>, и далее <math>v_{j}=0</math> при <math>j<i</math>, <math>v_{j}=u_{j-i+1}</math> при <math>j>i</math>, а <math>v_{i}=1</math>, если <math>u_{1}=0</math> и <math>v_{i}=\frac{u_{1}}{|u_{1}|}(1+|u_{1}|)</math> для остальных значений. При этом <math>\gamma = 1+|u_{1}|=|v_{i}|</math>.

После вычисления вектора <math>v</math> подстолбцы справа от ведущего модифицируются по формулам <math>x'=x-\frac{(x,v)}{\gamma}v</math>. Потом по аналогичным формулам модифицируются строки ниже ведущей. Благодаря ассоциативности этих операций после вычисления вектора <math>v</math> можно сразу выписать формулы модификации всех элементов справа и снизу от ведущих столбца и строки. Оказывается, что если для каждого столбца матрицы <math>x^{(j)}</math> с номером <math>j</math> известно <math>\beta_{j}=\frac{(x^{(j)},v)}{\gamma}</math>, то для модифицируемого элемента матрицы <math>y</math> в позиции <math>(i,j)</math> выполняется модификация <math>y' = y - \beta_{i} v_{i} - \beta_{j} v_{j} - \Delta v_{i} v_{j}</math>, где <math>\Delta = \frac{(\beta,v)}{\gamma}</math>. При этом все эти модификации на каждом конкретном шаге алгоритма для разных пар <math>(i,j)</math> можно выполнять независимо друг от друга, в том числе и параллельно.

=== Вычислительное ядро алгоритма ===

[[File:HausLeftSym1.png|thumb|right|800px|Рисунок 1. Граф первой половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-4</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Зелёные кружки - операция вида <math>a+b^2</math>, салатовые - операция вида <math>a+bc</math>. Синий кружок - вычисление параметров матрицы отражения, светло-красные - вычисление коэффициентов <math>\beta_i</math>для следующего полушага, жёлтые - вычисление вектора <math>v</math>.]]
[[File:HousLeftSym2.png|thumb|right|600px|Рисунок 2. Граф второй половины шага алгоритма приведения к трёхдиагональному виду с отображением входных данных. Изображён граф первой половины шага с номером <math>n-3</math>. Квадраты - результаты выполнения предыдущего шага. Если шаг первый, то это входные данные. Синий, жёлтые и светло-красные кружки выполняются на первом полушаге (см. Рисунок 1). Голубые кружки - операции <math>a+bc</math>, зелёное - умножение, чёрные - операции <math>a+bc+de+fce</math>.]]

Основную часть алгоритма составляют вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math>справа от текущего, а также проводимые над нижним правым квадратом матрицы операции вида <math>y'=y-ab-cd-fbd</math>, с учётом симметрии матрицы.

=== Макроструктура алгоритма ===

Как уже сказано в описании ядра, основная часть - вычисления на каждом шагу скалярных произведений <math>(s,s)</math> и <math>(x,v)</math> для всех подстолбцов <math>x</math> справа от текущего, а также массовые покомпонентные операции <math>y'=y-ab-cd-fbd</math>. При этом, однако, строгая последовательность выполнения первых двух подшагов не обязательна, в силу связи получаемых векторов <math>s</math> и <math>v</math> можно одновременно с <math>(s,s)</math> вычислять и произведения <math>(x,s)</math> с последующим выражением через них коэффициентов модификации. Это позволяет почти вдвое уменьшать критический путь графа алгоритма.

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

Последовательность выполнения алгоритма обычно записывается как последовательное "обнуление" поддиагональных элементов столбцов, начиная с 1-го столбца и заканчивая предпоследним <math>(n-1)</math>-м.

При этом в каждом "обнуляемом" <math>i</math>-м столбце "обнуляются" сразу все его поддиагональные элементы одновременно, с <math>(i+1)</math>-го до <math>n</math>-го.

Каждое "обнуление" <math>i</math>-го столбца состоит из двух шагов:
а) вычисление параметров матрицы отражения <math>U_{i}</math> такой, чтобы при умножении на неё слева "обнулились" все поддиагональные его элементы;
б) одновременное умножение слева матрицы отражения <math>U_{i}</math> и справа матрицы отражения <math>U_{i}^T</math>на текущую версию матрицы.

=== Последовательная сложность алгоритма ===

В последовательной версии основная сложность алгоритма определяется прежде всего вычислениями скалярных произведений векторов, а также массовых модификаций элементов вида <math>y'=y-\alpha v - \beta w - \Delta vw</math>. Они, если не учитывать возможную разреженность, составляют (в главном члене) по <math>O(n^3)</math> операций действительного умножения и сложения/вычитания.

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

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

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

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

Для понимания ресурса параллелизма в симметричном приведении матрицы порядка <math>n</math> к трёхдиагональной методом Хаусхолдера нужно рассмотреть критический путь графа.

Как видно из описания разных вершин, вычисления при "обнулении" <math>i</math>-го столбца параметров отражения и скалярных произведений состоят из основной части - ветви длиной по <math>2(n-i)</math> умножений и сложений - и коррекции вычислений, которые составляют <math>O(1)</math> операций.

Поэтому по грубой (без членов низших порядков) оценке критический путь метода Хаусхолдера будет идти через <math>n^2</math> умножений и <math>n^2</math> сложений/вычитаний.

Поэтому в параллельном варианте, как и в последовательном, основную долю требуемого для выполнения алгоритма времени будут определять операции вида <math>a+bc</math>.

При классификации по высоте ЯПФ, таким образом, метод Хаусхолдера относится к алгоритмам ''с квадратичной сложностью''. При классификации по ширине ЯПФ его сложность будет также ''квадратичной'' (без расширения ряда ярусов, связанных с векторными операциями сложения, пришлось бы увеличить вдвое длину критического пути).

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

'''Входные данные''': плотная симметричная квадратная матрица <math>A</math> (элементы <math>a_{ij}</math>).

'''Объём входных данных''': <math>(n^2+n)/2</math>.

'''Выходные данные''': трёхдиагональная матрица <math>D</math> (ненулевые элементы <math>r_{ij}</math> в последовательном варианте хранятся в элементах исходной матрицы <math>a_{ij}</math>), унитарная (ортогональная) матрица Q - как произведение матриц Хаусхолдера (отражения) (их вектора нормалей к плоскостям отражения в последовательном варианте хранятся в поддиагональных элементах исходной матрицы <math>a_{ij}</math> и в одном дополнительном столбце размерности n).

'''Объём выходных данных''': <math>(n^2+3n)/2</math>.

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

Соотношение последовательной и параллельной сложности, как хорошо видно, является ''линейным'', что даёт определённый стимул для распараллеливания. Однако у наискорейшей ЯПФ ширина ''квадратична'', что указывает на дисбаланс между загруженностями устройств при попытке её реально запрограммировать. Поэтому более практично даже при хорошей (быстрой) вычислительной сети оставить количество устройств (например, узлов кластера) ''линейным'' по размеру матрицы, что удвоит критический путь реализуемой ЯПФ.

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная погрешность в методе отражений (Хаусхолдера) растет ''линейно'', как и в методе Гивенса (вращений).

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

В варианте с кратчайшим критическим путём графа алгоритма (с использованием зависимости между обнуляемым вектором и направляющим вектором отражения) метод Хаусхолдера (отражений) приведения квадратной симметричной вещественной матрицы к трёхдиагональному виду на Фортране 77 можно записать так:

<source lang="fortran">
DO I = 1, N-2

DO K = I, N
SX(K)=A(N,I)*A(N,K)
END DO
DO J = N-1, I+1, -1
SX(I)=SX(I)+A(J,I)*A(J,I)
END DO
DO K = I+1, N
DO J = N-1, K, -1
SX(K)=SX(K)+A(J,I)*A(J,K)
END DO
DO J = K-1,I+1,-1
SX(K)=SX(K)+A(J,I)*A(K,J)
END DO
END DO

ALPHA = SQRT (SX(I))
IF (A(I+1,I).NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = A(I+1,I)*BETA+SIGN(1.,A(I+1,I))
A(I+1,I)=ALPHA
G=1./ABS(SX(I)) ! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
IF (ALPHA.NE.0.) THEN
BETA = 1./ALPHA
DO J = I+2, N
A(J,I)=A(J,I)*BETA
END DO
SX(I) = -1.
A(I+1,I)=ALPHA
G=1.! 1/gamma
SX2=0.
DO K = I+2, N
SX(K)=SX(K)*BETA*G+SIGN(A(K,I+1),SX(I))
SX2=SX(K)*A(K,I)+SX2
END DO
SX2=G*SX2
DO K = I+2, N
A(K,K) = A(K,K)-2*A(K,I)*SX(K)+SX2*A(K,I)**2
DO J = K+1, N
A (J,K) = A(J,K)-A(J,I)*SX(K)-A(K,I)*SX(I)+SX2*A(J,I)*A(K,I)
END DO
END DO
ELSE
SX(I)=1.
END IF
END IF

END DO
</source>

Здесь симметричная трёхдиагональная матрица хранится в диагонали и нижней кодиагонали массива A, вектора v - в поддиагональной части массива, за исключением первых их элементов, для которых выделен массив SX.

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

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

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

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:householder_qtq_1.png|thumb|center|700px|Рисунок 3. Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Общий профиль обращений в память]]

На рис. 3 представлен профиль обращений в память для реализации метода Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду. Данный профиль обладает явной итерационной структурой, при этом видно, что итерации очень похожи. Основное их отличие заключается в наборе используемых данных – на каждой следующей итерации несколько первых элементов отбрасываются их рассмотрения, то есть чем позже итерация, тем меньше данных в ней задействовано. Также можно отметить, что число обращений в каждой последующей итерации немного уменьшается. Для того чтобы проанализировать общий профиль, в таком случае чаще всего достаточно изучить одну итерацию. Рассмотрим самую первую из них более детально.

На рис. 4 показан набор обращений в рамках первой итерации (выделен на рис. 3 зеленым). Его можно разбить на несколько фрагментов и рассмотреть их отдельно. Строение фрагментов 2-5 можно оценить по общему графику для итерации. Фрагмент 2 представляет собой набор последовательных переборов в обратном порядке с небольшим шагом, причем число элементов в переборе постепенно уменьшается. Такое строение характеризуется достаточно высокой пространственной локальностью, поскольку часто происходит обращений к близко расположенным данным, однако низкой временной, поскольку данные повторно не используются. То же самое верно и для фрагмента 4, основное отличие которого заключается в том, что переборы выполняются в прямом порядке. Отметим, что некоторое искривление данного фрагмента связано не со строением самого фрагмента, а с разным числом параллельно выполняющихся обращений (см., например, правую область фрагмента 6), чего не наблюдается при выполнении фрагмента 2.

[[file:householder_qtq_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, одна итерация]]

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

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

[[file:householder_qtq_3.png|thumb|center|500px|Рисунок 5. Профиль обращений, одна итерация, фрагмент 1]]

Далее рассмотрим детально фрагмент 6 (рис. 6). Здесь можно увидеть, что повторные обращения к данным выполняются не подряд, а через некоторые промежутки, однако число задействованных элементов также очень невелико, так что и в этом случае локальность (и пространственная, и временная) будет высокой.

[[file:householder_qtq_4.png|thumb|center|500px|Рисунок 6. Профиль обращений, одна итерация, фрагмент 6]]

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

===== Количественная оценка локальности =====

Оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 7 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью в данном случае достаточно высока – значение daps лишь немногим уступает тесту Linpack, который обладает высокой эффективностью работы с памятью, и немного превосходит, например, реализацию метода Якоби или метода Гаусса.

[[file:householder_qtq_daps.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки daps]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости вширь реализации согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [16:256] с шагом n^2;
* размер матрицы [1000 : 32000] с шагом 1000.

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

* минимальная эффективность реализации 7.511e-06%;
* максимальная эффективность реализации 0.0746%.

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации DQDS в зависимости от изменяемых параметров запуска.

[[file:PDGEQRF PERF.png|thumb|center|700px|Рисунок 8. Параллельная реализация циклической редукции. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:PDGEQRF EFF.png|thumb|center|700px|Рисунок 9. Параллельная реализация циклической редукции. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

В сравнении с методом Гивенса, который имеет естественное двумерное блочное разбиение на основе точечного метода, метод Хаусхолдера из-за худших характеристик локальности (наличие пучков рассылок) и меньшего количества независимых обобщённых развёрток графа не так хорош для реализаций на системах с распределённой памятью, как для систем с общей памятью. Поэтому на массово параллельных системах с распределённой памятью следует применять метод Хаусхолдера (если уж именно его нужно реализовать) не в точечной версии, а в разрабатываемых исследователями блочных вариантах. Следует отметить, что эти варианты - не блочная нарезка описанного метода, а самостоятельные методы. Особенно их применение рекомендуется в случаях с большой разрежённостью матрицы.

=== Существующие реализации алгоритма ===

Большинство пакетов от LINPACKа и LAPACKa до SCALAPACKa используют для QR-разложения матриц именно метод Хаусхолдера, правда, в различных модификациях (обычно с использованием BLAS). Существует большая подборка исследовательских работ по блочным версиям.

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

[[Категория:Статьи в работе]]
[[Категория:Разложения матриц]]

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

2016-12-07T12:49:21Z

Teplov:

{{Assignment|Teplov}}

{{algorithm
| name = Алгоритм устойчивой кластеризации с иcпользованием связей
| serial_complexity = <math>O(M^2 + M^2m_{nbr} + M^{2}logM)</math>
| pf_height = <math>O(MlogM)</math>
| pf_width = <math>O(M^2)</math>
| input_data = <math>M \times N</math>
| output_data = <math>M</math>
}}

Автор описания: [[Участник:viktorrulev|В.А. Рулев]].

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

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

Кластеризация (кластерный анализ) — задача разбиения заданной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались. Каждый объект из выборки характеризуется рядом признаков, которые могут быть вещественными, целочисленными, категорийными (то есть принимающими значения из какого-либо множества) и другими. Множество значений, которые может принимать признак, называется доменом этого признака. Так, например, у объекта '''кошка''' может быть категорийный признак '''порода''', доменом которого является множество '''[персидская, бенгальская, сфинкс, мейн-кун, ...]'''.

'''Алгоритм устойчивой кластеризации с иcпользованием связей (robust clustering using links, ROCK)''' был предложен в 2000 году Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories) <ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim ROCK: A robust clustering algorithm for categorical attributes. 2000. Information Systems. Vol 25, Issue 5, Pages 345-366</ref> для кластеризации объектов с категорийными признаками.

Алгоритм устойчивой кластеризации с использованием связей предназначен для работы с объектами типа "транзакция" ("покупательская корзина"). Транзакция представляет собой множество товаров, приобретенных покупателем у поставщика. Каждому товару, который есть в наличии у поставщика, в транзакции соответствует отдельный признак, который принимает значение '''true''', если товар присутствует в транзакции, и '''false''', если товар в транзакции отсутствует.

=== Математическое описание алгоритма ===

В ходе кластеризации <math>M</math> имеющихся транзакций <math>P=\{p_1,...,p_M\}</math> (каждая транзакция имеет <math>N</math> признаков) должны быть разделены на <math>K</math> непересекающихся подмножеств (кластеров) <math>C_1, ..., C_K</math> таким образом, чтобы полученные кластеры максимизировали некоторую критериальную функцию <math>E(C_1, ..., C_K)</math>.

Будет называть две транзакции <math>p_1</math> и <math>p_2</math> '''соседями''', если мера сходства <math>neighbour(p_1,p_2)</math> этих транзакций больше некоторого заранее заданного порогового значения <math>\theta</math> В качестве меры сходства в алгоритме устойчивой кластеризации с использованием связей используется основанная на коэффициенте Жаккара мера сходства <math>sim(p_1,p_2)</math>. В ней <math>N(C_i)^{1+2f(\theta)}</math> имеет смысл ожидаемого (среднего) количества связей внутри одного кластера.

'''Количеством связей''' <math>link(p_1,p_2)</math> между двумя транзакциями <math>p_1</math> и <math>p_2</math> будем называть количество общих соседей этих транзакций.

Для того, чтобы сформировать кластеры, удовлетворяющие поставленному условию, необходимо последовательно объединять среди имеющихся кластеров такие пары кластеров, для которых метрика <math>goodness(C_i,C_j)</math> достигает максимального значения среди всех пар кластеров. На начальном этапе каждая транзакция считается отдельным кластером.

Формулы метода:
:<math>
neighbour(p_1,p_2)=(sim(p_1,p_2)>\theta)
</math>
 
:<math>
sim(p_1,p_2)=\frac{N(p_1 \cap p_2)}{N(p_1 \cup p_2)}
</math>
 
:<math>
link(p_1,p_2)=N \Big( \{ p \in P | sim(p_1,p) < \theta \} \cap \{ p \in P | sim(p_2,p) < \theta \} \Big)
</math>
 
:<math>
E(C_1,...,C_K)=\sum_{i=1}^{K}N(C_i) \ast \sum_{p_q,p_r \in C_i}\frac{link(p_q,p_r)}{N(C_i)^{1+2f(\theta)}}
</math>
 
:<math>
f(\theta)=\frac {1-\theta}{1+\theta}
</math>
 
:<math>
goodness(C_i,C_j)=\frac {\sum_{p_r \in C_i, p_q \in C_j}{link(p_r,p_q)}} {(N(C_i) + N(C_j))^{1+2f(\theta)} - N(C_i)^{1+2f(\theta)} - N(C_j)^{1+2f(\theta)}}
</math>

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма можно разделить на два основных этапа:

# Вычисление количества связей между каждой парой транзакций (<math>\frac {M \times M} {2}</math> вычислений количества связей)
# Последовательные объединения пар наиболее подходящих кластеров (<math>M-K</math> поисков пар и объединений)

Подробнее оба этапа будут описаны ниже.

=== Макроструктура алгоритма ===

На макроуровне можно выделить следующие шаги алгоритма:

'''Шаг 1:''' вычисление соседних транзакций.

'''Шаг 2:''' вычисление количества связей между всеми транзакциями.

'''Шаг 3:''' построение для каждого кластера упорядоченного списка значений метрики goodness со всеми остальными кластерами

'''Шаг 4:''' построение общего упорядоченного списка значений метрики goodness

'''Шаг 5 (повторяется то тех пор, пока количество кластеров не достигнет желаемого)'''

'''Шаг 5.1:''' объединение двух кластеров с наилучшим goodness

'''Шаг 5.2:''' обновление списков кластеров

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

Ниже приведен псевдокод схемы реализации последовательного алгоритма:

<source lang="pascal">
procedure compute_links(P)
begin
for each p[i], p[j] in P do
if sim(p[i], p[j]) > theta
is_neighbour[i, j] = true
else
is_neighbour[i, j] = false

links[i, j] = 0
for each p[i], p[j] in P do
for p[k] in P do
if is_neighbour[i, k] && is_neighbour[j, k]
links[i, j] = links[i, j] + 1
end

procedure cluster(P, k)
begin
links := compute_links(P)

for each p in P do
q[p] := build_local_list(links, p)
Q := build global_list(P, q)

while size(Q) > k do
begin
u := extract_max(Q)
v := extract_max(q[u])
w := merge(u, v)
delete(Q, v)

for each x in (q[u] or q[v]) do
begin
delete(q[x], u);
delete(q[x], v)
insert(q[x], w, goodness(x, w))
insert(q[w], x, goodness(x, w))
update(Q, x, q[x])
end

insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end
</source>

=== Последовательная сложность алгоритма ===

Рассмотрим сложности шагов алгоритма из раздела 1.4.

'''Шаг 1:''' выполняется с помощью двух вложенных циклов и содержит <math>O(M^2)</math> операций

'''Шаг 2:''' задача сводится к умножению полученной на предыдущем шаге матрицы соседства на саму себя. Это действие быть выполнено с помощью наивного метода за <math>O(M^3)</math> операций. С помощью алгоритма Копперсмита — Винограда это можно сделать за <math>O(M^{2.37})</math> операций.<ref>Donald Coppersmith and Shmuel Winograd. Matrix multiplication via arithmetic progressions. In Proc. of the 19th Annual ACM Symposium on Theory of Computing. 1987.</ref> В случае, если среднее количество соседей каждой транзакции значительно меньше общего количества транзакций, связи могут быть вычислены за <math>O(M^2m_{nbr})</math>, где <math>m_{nbr}</math> - среднее количество соседей транзакции.

'''Шаг 3:''' имеет сложность <math>O(M)</math>.<ref>Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest. Introduction to
Algorithms. The MIT Press, Massachusetts, 1990.</ref>

'''Шаг 4:''' имеет такую же вычислительную сложность, как и предыдущий шаг.

'''Шаг 5:''' вычислительная сложность каждой итерации цикла составляет <math>O(MlogM)</math>, так как в худшем случае в ходе итерации выполняется <math>M</math> вставок элемента в упорядоченный список. Желаемое количество кластеров <math>K</math> мало по сравнению с <math>M</math>, следовательно можно считать, что нужно выполнить <math>M</math> итераций цикла. Таким образом, общая вычислительная сложность цикла равна <math>O(M^{2}logM)</math>.

Таким образом, общую последовательную сложность алгоритма в общем случае можно оценить, как

:<math>O(M^2 + M^{2.37} + M^{2}logM)</math>

или в случае небольшого количества соседних транзакций, как

:<math>O(M^2 + M^2m_{nbr} + M^{2}logM)</math>.

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

''Информационный граф перемножения плотных матриц с подробным описанием представлен в статье [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|перемножение плотных матриц]]''

Ниже представлен информационный граф наиболее интересного для рассмотрения этапа алгоритма устойчивой кластеризации с использованием связей - тела цикла (полупрозрачным показана следующая итерация цикла) при <math>n=5</math>.

[[file:Rock-graph.png|thumb|center|1000px|Рисунок 1. Граф тела цикла; merge - объединение кластеров, insert - вставка goodness с новым кластером в упорядоченные списки соответствующих кластеров.]]

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

'''Шаг 1:''' каждая итерация цикла может быть выполнена независимо от всех остальных. Таким образом, в этом случае ширина ЯПФ равна <math>O(M^2)</math>, а высота - <math>O(1)</math>.

'''Шаг 2:''' высота ЯПФ равна <math>O(M)</math>, а ширина - <math>O(M^2)</math> (''см. [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|перемножение плотных матриц]]'')

'''Шаг 3:''' имеет небольшую асимптотическую сложность, может быть выполнен последовательно.

'''Шаг 4:''' аналогично шагу 3.

'''Шаг 5:''' каждая итерация цикла может быть выполнена только после полного завершения предыдущей, а внутри каждой отдельной итерации все вставки могут быть выполнены независимо друг от друга. Следовательно ширина ЯПФ в этом случае равна <math>O(M)</math>, а высота ЯПФ равна <math>O(MlogM)</math>.

Таким образом, высота ЯПФ зависит от размерности задачи как <math>O(MlogM)</math>, а ширина ЯПФ - как <math>O(M^2)</math>.

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

'''Входные данные''': информация об <math>M</math> транзакциях, каждая их которых имеет <math>N</math> бинарных атрибутов.

'''Объём входных данных''': <math>M \times N</math> бинарных переменных. В силу того, что обычно в большинстве случаев лишь небольшое количество атрибутов транзакции имеет значение "1", каждую транзакцию можно хранить в виде списка номеров атрибутов, значения которых равны "1".

'''Выходные данные''': <math>K</math> кластеров.

'''Объём выходных данных''': <math>M</math> индексов транзакций, распределенных в <math>K</math> списков.

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

Вычислительная сложность последовательного алгоритма в общем случае равна <math>O(M^{2.37})</math>, а в случае небольшого количества соседних транзакций у каждой транзакции сложность равна <math>O(M^{2})</math>.

Вычислительная мощность алгоритма (соотношение количества операций к объему входных и выходных данных) в общем случае равна O(M^{1.37}), в а случае небольшого количества соседних транзакций (то есть в том случае, для которого и разрабатывался алгоритм) вычислительная мощность линейна.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как показано выше, является квадратичным.

== Программная реализация алгоритма ==

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

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

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

=== Масштабируемость алгоритма и его реализации ===

Проведём исследование масштабируемости параллельной реализации алгоритма устройчивой кластеризации с использованием связей, выполненной с использованием OpenMP. Исследование проводилось на персональном компьютере HP Pavilion dv6 (процессор Intel Core i7 3610QM 2300 МГц, 8 логических ядер).

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число нитей [1 : 8] с шагом 1;
* количество точек [500 : 1500] с шагом 100.

На следующих рисунках приведены графики времени выполнения выбранной реализации разложения Холецкого в зависимости от изменяемых параметров запуска.

[[file:ROCK results.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма устойчивой кластеризации с использованием связей. Изменение времени выполнения кластеризации в зависимости от количества точек и от количества параллельных нитей.]]

'' '''Для проверяющего''': я сделал OpenMP и MPI реализации этого алгоритма, но при запуске на Ломоносове они не дают никакого ускорения в зависимости от количества нитей/процессов. Я могу предоставить графики, показывающие это. Также я готов предоставить исходники обеих программ, но не могу выложить их на git.algowiki-project.org, потому что мне не приходит письмо с подтверждением регистрации.''

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

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

=== Существующие реализации алгоритма ===

Алгоритм устойчивой кластеризации с иcпользованием связей реализован в пакете CBA языка R.<ref>https://en.wikibooks.org/wiki/Data_Mining_Algorithms_In_R/Clustering/RockCluster</ref>

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

<references \>

Самоорганизующаяся карта Кохонена (алгоритм кластеризации)

2016-12-07T12:35:52Z

Teplov:

{{assignment|Teplov}}
Авторы проекта: [[Участник:Eugene|Быковец Евгений Владимирович (620 группа)]] и [[Участник:Crowslord|Ворона Игорь Игоревич (620 группа)]]
Быковец Е.В.: 1.1,1.2,1.3,1.4,1.5,2.7
Ворона И.И.: 1.6,1.7,1.8,1.9,1.10,3.0

{{algorithm
| name = Алгоритм кластеризации, основанный на самоорганизующихся сетях Кохонена
| serial_complexity = <math>O(TMn) + O(M^2)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>O(nN)</math>
| output_data = <math>O(nM)</math>
}}

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

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

Cамоорганизующаяся карта Кохонена (Self-Organizing Map, SOM) представляет из себя вычислительный метод, предназначенный для задач, в первую очередь, кластеризации и визуализации, а также анализа данных из пространств высокой размерности (иначе, многомерных данных), полученных экспериментально. Методы был предложен Туево Кохоненом (1982). Прародителями модели самоорганизующейся сети Кохонена были ранние нейросетевые модели (в частности, модель ассоциативной памяти и модель адаптивного обучения).

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

Архитектура самоорганизующейся карты Кохонена следующая: имеется два слоя - входной слой (распределительный) нейроноы и выходной слой (слой Кохонена) нейронов, при этом нейроны второго слоя расположены в виде двумерной решетки (обычно сетка либо квадратная, либо шестиугольная, об этом далее), так, что каждый нейрон из первого слоя соединен с каждым нейроном второго слоя (см. рис. 1) [[Файл:General Kohonen.png|thumb|200px|right|Рис. 1. Общая структура карты Кохонена]]Количество нейронов входного слоя равно размерности исходного пространства. Чаще нейроны слоя Кохонена принято называть кластерными элементами. Более точно, их количество определяет количество кластеров, на которые карта может разбить данные, которые поданы на распределительный слой. Чем больше кластерных элементов, тем более гранулярная кластеризация. Как уже было сказано, топология слоя Кохонена может быть представлена либо виде четырехугольной сетки, либо в виде шестиугольной сетки. Второй вариант более привлекателен в силу того, что расстояния для каждого нерона до каждого соседнего с ним нейрона одинаковые. Более наглядно это представлено на рисунках (cм. рис. 2а, рис. 2б) [[Файл:quadr.jpg|thumb|200px|right|Рис. 2а.Четырехугольная решетка слоя Кохонена]] [[Файл:hex.png|thumb|200px|right|Рис. 2б.Шестиугольная решетка слоя Кохонена]]

Каждый нейрон выходного слоя определяется вектором весов (размерность вектора - есть разность входного пространства) и упорядоченной парой : <math>(x,y)</math>, определяющую позицию нейрона на карте Кохонена.

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

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

== Математическое описание алгоритма ==
=== Используемые обозначения ===

<math>t</math> - номер итерации,

<math>n</math> - размерность исходного пространства,

<math> \chi \subset R^n</math> - обучающая выборка,

<math> \Phi \subset R^n </math> - тестовая выборка,

<math> N = |\chi|</math> - размер обучающей выборки,

<math> K = |\Phi|</math> - размер тестовой выборки,

<math> a </math> - высота слоя Кохонена,

<math> b </math> - ширина слоя Кохонена,

<math> M = a \times b </math> - общее количество нейронов в слое Кохонена,

<math> ne_j, j=1,...M </math> - нейрон с индексом <math>j</math>,

<math>\vec{x}^{(i)}(t) = (x_1^{(i)}(t),...,x_n^{(i)}(t)), i=1,..,N</math> - <math>i</math>-й вектор, подлежайщий кластеризации,

<math>\vec{w}^{(j)}(t) = (w_1^{(j)}(t),...,w_n^{(j)}(t)), j = 1,..,M</math> - вектор весовых коэффициентов для <math>j</math>-го нейрона,

<math> r_k</math> - положение <math>k</math>-го нейрона в топологии карты, то есть <math>(i_k,j_k)</math>,

<math> h_{ij}(t)</math> - функция соседства между нейронами с индексами <math>i</math> и <math>j</math> на итерации t,

<math> h(d,t) </math> - функция от расстояния между нейронами,

<math> \alpha(t)</math> - скорость обучения сети,

<math> \sigma(t) </math> - функция, уменьшающая количество соседей с при увеличении итерации (монотонно убывающий),

<math> T </math> - максимальное число итераций алгоритма обучения - может быть задано фиксировано, либо же равно мощности обучающей выборки, то есть <math> N </math>.

=== Алгоритм обучения ===

Шаг №0. Определить значение параметров алгоритма: используемые метрики, функции <math>\alpha(t) </math>, <math>\sigma(t) </math>, <math>t:= 0 </math>

Шаг №1. Инициализировать векторы начальных весов нейронов <math> \vec{w}^{(j)}(0) \forall j=1,..,M</math>. Подробнее о стратегии начальной инициализации далее.

шаг №2. Если есть еще элементы в обучающей выборке, вытащить случайным образом (например, индекс <math>i</math> - может быть реализацией случайной величины из равномерного дискретного распределения на <math> [0,N] </math>) входной вектор <math>\vec{x}^{(i)}(t), N:=N-1, \chi = \chi \setminus \vec{x}^{(i)}(t)</math>, в противном случае алгоритм завершает свою работу

шаг №3. Для <math>\vec{x}^{(i)}(t)</math> и <math> \vec{w}^{(j)}(t) \forall j=1,..,M</math> найти <math> = \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t)) = || \vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)||^2 </math>.

шаг №4. Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, M\}} \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t))</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}(t)</math> по рассматриваемой метрике <math> || \circ || </math>.

шаг №5. Для всех нейронов <math> ne_{j} </math> выполнить пересчет весовых векторов:
<math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>.

шаг №6. <math>t := t+1 </math>

шаг №7. Перейти к шагу 2.

=== Настройка алгоритма ===

В этом разделе опишем более подробно настраиваемые аспекты алгоритма.

==== Выбор начального приближения для <math>\vec{w}^{j}(0) \forall j=1,\dots,M</math> ====

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

Во-вторых, инициализацию весов можно проводить какими-то случайными значениями. Например можно взять нескорое распределение, пусть равномерное или нормальное, и для каждой сгенерировать псевдослучайное число из выбранного распределения, то есть <math> w_i^{(j)} \sim \mathbf P </math>, где <math> \mathbf P </math> - это заданное распределение. Плюсом данного подхода является простота однако, "настройка" в данном случае может быть долгой.

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

==== Выбор скорости обучения сети ====

Функцию скорости обучения сети <math>\alpha(t)</math> можно выбрать, например, следующим образом:

Самый простой способ: <math>\alpha(t) := \frac{A}{B+t}</math>, где <math>A = const, B = const </math>

Экспоненциальная скорость обучения: <math>\alpha(t) := \alpha_0 e^{ -\frac{t}{\lambda}}, \lambda \in (0, 1), \lambda = const, \alpha_0 = const</math>

Показательная скорость обучения: <math>\alpha(t) := \lambda^{\frac{t}{T}}, \lambda \in (0, 1), \lambda = const</math>

==== Выбор функции соседства между нейронами ====

Обычно полагают <math> h_{cj}(t) := \alpha(t) h(d,t) </math>, где <math> d = || ne_c - ne_j ||, c </math> -индекс нейрона победителя, при этом:

<math> h(d,t) = \begin{cases}const, d\leq \sigma(t) \\0, d > \sigma(t) \end{cases}</math>

<math> h(d,t) = e ^{-\frac{d^2}{2(\sigma(t)^2)}}</math>, где <math>\sigma(t)</math> - это некоторый сомножитель, уменьшающий количество соседей, которые будут подвержены корректировке весов с увеличением итераций, эта функция монотонно убывает.

Функция <math> \sigma(t) </math> также является параметром алгоритма. Возможная функциональная зависимость для нее:
<math>\sigma(t) = \frac{\sigma_0}{1 + \frac{t}{T}}</math>.

Стоит отметить, что имеется много других эвристических мер сходств которые присваивают ненулевые веса внутри некоторого радиуса, это позволяет производить вычисления не для всех соседей.

=== Алгоритм работы карты ===

шаг 0. Пока есть вектора в тестовой выборке извлечь (последовательно), <math>\vec{x}^{(i)}, K:=K-1, \Phi = \Phi \setminus \vec{x}^{(i)}</math>, в противном случае алгоритм завершает свою работу.

шаг 1. Для <math>\vec{x}^{(i)}</math> и <math> \vec{w}^{(j)} \forall j=1,..,M</math> найти <math> \rho(\vec{x}^{(i)}, \vec{w}^{(j)}) = || \vec{x}^{(i)} - \vec{w}^{(j)}||^2 </math>.

шаг 2. Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}, \vec{w}^{(j)})</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}</math> по рассматриваемой метрике <math> || \circ || </math> и относим <math>\vec{x}^{(i)} </math> к кластеру, соответствующему нейрону <math>ne_c</math>.

шаг 3. Переход к шагу 0.

== Вычислительное ядро алгоритма ==

Вычислительное ядро алгоритма обучения составляет (соответсвенно, пункты 3,4,5 алгоритма обучения):

* подсчет расстояний между входным вектором и всеми нейронами:

Для <math>\vec{x}^{(i)}(t)</math> и <math> \vec{w}^{(j)}(t) \forall j=1,..,M</math> найти <math> = \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t)) = || \vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)||^2 </math>.

* Поиск минимума между всеми найденными расстояниями для нахождения нейрона-победителя:

Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t))</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}(t)</math> по рассматриваемой метрике <math> || \circ || </math>.

* Корректировка весовых векторов: сюда же входит поиск расстояний между всеми нейронами в рамках заданной топологии, а также вычисление функции соседства:

Для всех нейронов <math> ne_{j} </math> выполнить пересчет весовых векторов:
<math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>.

Вычислительное ядро алгоритма работы составляет (соответсвенно, пункты 1, 2 алгоритма работы):

* подсчет расстояний между входным вектором и всеми нейронами:

Для <math>\vec{x}^{(i)}</math> и <math> \vec{w}^{(j)} \forall j=1,..,M</math> найти <math> \rho(\vec{x}^{(i)}, \vec{w}^{(j)}) = || \vec{x}^{(i)} - \vec{w}^{(j)}||^2 </math>.

* Поиск минимума между всеми найденными расстояниями для нахождения нейрона-победителя:

Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}, \vec{w}^{(j)})</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}</math> по рассматриваемой метрике <math> || \circ || </math> и относим <math>\vec{x}^{(i)} </math> к кластеру, соответствующему нейрону <math>ne_c</math>.

== Макроструктура алгоритма ==
В алгоритме обучения можно выделить 4 макрофазы:

* Начальная инициализация всех весов: построение матрицы <math> \mathbf{ W(0)} \in \mathbf {R^{N \times M}} </math>, столбцами которой являются весовые вектора всех нейронов.

* Выполнение следующих фаз <math> \mathbf T </math> раз:
** Вычисление вектора расстояний <math> \mathbf D \in \mathbf {R^M} </math>, в котором хранятся вектора расстояний от вектора <math> \mathbf X </math> до векторов матрицы <math> \mathbf {W(t)} </math>.
** Нахождение индекса минимума в векторе <math> \mathbf D </math> - индекса нейрона победителя;
** Корректировка всех весов: получение матрицы <math> \mathbf {W(t+1)} </math>

В алгоритме работы алгоритма можно выделить две макрофазы:

* Выполнение следующих фаз <math> \mathbf K </math> раз:
** Вычисление вектора расстояний <math> \mathbf D \in \mathbf {R^M} </math>, в котором хранятся вектора расстояний от вектора <math> \mathbf X </math> до векторов матрицы <math> \mathbf {W} </math>.
** Нахождение индекса минимума в векторе <math> \mathbf D </math> - индекса нейрона победителя и определение входного вектора в кластер, соответсвующий нейрону-победителю;

Также можно выделить математические операции, используемые в вышеприведенных:
* <math>\vec{x}^{T} \vec{y}</math> - скалярное произведение вектров;
* <math>\vec{x} + \vec{y}</math> - сложение двух векторов;
* <math>\lambda \vec{x}</math> - умножение вектора на скаляр;
* <math>\min_i x_i</math> - поиск минимального элемента в векторе <math>\vec{x}</math>;
* Вычисление функции соседства <math> h_{ci}(t) </math>

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

Схему реализации последовательного алгоритма обучения запишем в виде псевдокода:
<syntaxhighlight lang=oberon2>
SetAlgorithmParameters()
CalculateDistancesBetweenNeuronsInEuclidianPlane()
W = SetNeuronWeightsVector()
FOR t = 1 to T do
x = ChooseInputVector()
D = InitialiseDistancesVector()
FOR n = 1 to M do
d = CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)
PutCalculatedDistanceToDistancesVector(D, d)
END FOR
ne_c = FindNeuronWinner(D)
FOR n = 1 to M do
CorrectNeuronsWeightsVector(W)
END FOR
END FOR
</syntaxhighlight>

Схему реализации последовательного алгоритма работы запишем в виде псевдокода:
<syntaxhighlight lang=oberon2>
FOR t = 1 to T do
x = ChooseInputVector()
D = InitialiseDistancesVector()
FOR n = 1 to K do
d = CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)
PutCalculatedDistanceToDistancesVector(D, d)
END FOR
ne_c = FindNeuronWinner(D)
DefineInputVectorToCluster()
END FOR
</syntaxhighlight>

Дадим комментарии по некоторым функциям:
<math>SetAlgorithmParameters()</math> - установка параметров алгоритма проводится исследователем для увеличения/уменьшения гранулярности кластеризации;

<math>CalculateDistancesBetweenNeuronsInEuclidianPlane()</math> - вычисление матрицы расстояний между всеми нейронами в Евклидовой плоскости, в соответствии с их расположением в слое Кохонена - эта информация потребуется <math>CorrectNeuronsWeightsVector(W)</math>.

<math>W = SetNeuronWeightsVector()</math> - установка векторов веса нейронов (стратегии инициализации были рассмотрены выше: случайным образом, значениями из обучающей выборки, с помощью значений из пространства векторов, натянутого на главные компоненты);

<math>x = ChooseInputVector()</math> - выбор входного вектора из выборки (стратегия выбора также было рассмотрена выше: индекс вектора в обучающей выборке - реализация случайной величины из заданного распределения вероятностей, например);

<math>D = InitialiseDistancesVector()</math> - заполнение массива растояний нулями;

<math>d= CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)</math> - вычисление расстояния между входным вектором и вектора веса нейрона по выбранной метрике (например, евклидовом);

<math>PutCalculatedDistanceToDistancesVector(D, d)</math> - добавление вычисленного расстояния между входным вектором и вектором веса текущего нейрона в массив расстояний;

<math>ne_c = FindNeuronWinner(D)</math> - нахождение нерона победителя, индекс которого является индексом минимума в массиве расстояний;

<math>CorrectNeuronsWeightsVector(W)</math> - корректировка весов нейронов по формуле: <math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>;

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

== Последовательная сложность алгоритма ==
Начнём рассмотрение сложности последовательной реализации алгоритма Кохонена «сверху – вниз» начиная со сложности максимально абстрактного набора функций и потом конкретизируя сложность каждой функции в рамках фундаментальных вычислительных операций (присваивание, суммирование и т.п.). Это позволяет пересчитать сложность алгоритма Кохонена при условии замены функции составляющих его основу и при реализации его на целевую платформу.

'''I АЛГОРИТМ ОБУЧЕНИЯ'''

1) Уровень набора функций

:<math>Complexity(SOMLearning) = </math>

:<math>Complexity(SetAlgorithmParameters) +</math>

:<math>Complexity(CalculateDistancesBetweenNeuronsInEuclidianPlane) +</math>

:<math>Complexity(SetNeuronWeightsVector) +</math>

:<math>T \cdot Complexity(ChooseInputVector) +</math>

:<math>T \cdot Complexity(InitialiseDistancesVector) +</math>

:<math>T \cdot M \cdot Complexity(CalculateDistanseBetweenInputVectorAndNeuronWeightsVector) +</math>

:<math>T \cdot M \cdot Complexity(PutCalculatedDistanceToDistancesVector) +</math>

:<math>T \cdot Complexity(FindNeuronWinner) +</math>

:<math>T \cdot M \cdot Complexity(CorrectNeuronsWeightsVector)</math>

2) Уровень реализации функций в рамках фундаментальных операций

Будем считать, что следующие операции выполняются за константное время (<math>O(1)</math>):

:<math>mov</math> - присваивание

:<math>sqrt</math> - взятие квадратного корня из числа

:<math>rand</math> – генерация случайного числа

:<math>add</math> - сложение

:<math>sub</math> - вычитание

:<math>mul</math> - умножение

:<math>comp</math> - сравнение

:<math>exp</math> - экспоненцирование

:<math>div</math> - деление

Тогда:
:Так как параметров всегда конечное число и мы делаем допущение, что это число меньше M и T:

:<math>Complexity(SetAlgorithmParameters) = O(Complexity(mov)) = O(1)</math>

:<math>Complexity(CalculateDistancesBetweenNeuronsInEuclidianPlane) = </math>
:<math>O(M \cdot (M-1) \cdot (2 \cdot Complexity(sub) + 2 \cdot Complexity(mul) +</math>
:<math> Complexity(add) + Complexity(sqrt))) = O(M^2)</math>

:<math>Complexity(SetNeuronWeightsVector) = O(Mn \cdot Complexity(mov)) \vee O(Mn \cdot Complexity(rand))) = O(Mn)</math>

:<math>Complexity(ChooseInputVector) = O(n \cdot Complexity(mov))= O(n)</math>

:<math>Complexity(InitialiseDistancesVector) = O(M \cdot n \cdot Complexity(mov)) = O(M \cdot n)</math>

:<math>Complexity(CalculatedDistanseBetweenInputVectorAndNeuronWeightsVector) = O(n \cdot Complexity(sub)) +</math>
:<math>O(n \cdot Complexity(mul)) + O((n - 1) \cdot Complexity(add)) = O(n)</math>

:<math>Complexity(PutCalculatedDistanceToDistancesVector) = O(n \cdot Complexity(mov)) = O(n)</math>

:<math>Complexity(FindNeuronWinner) = O(M \cdot n \cdot Complexity(comp)) = O(Mn)</math>

:<math>Complexity(CorrectNeuronsWeightsVector) = O(nComplexity(add)) + O(nComplexity(mul)) + </math>
:<math>O(Complexity(NeighborhoodFunction)) = O(n) + O(Complexity(NeighborhoodFunction)) = O(n) +</math>
:<math> O(Complexity(exp) + Complexity(div)) = O(n)</math>

3) Конечная сложность

:<math>Complexity(SOMLearning) = O(1) + O(M^2) + O(Mn) + O(Tn) + O(TMn) + O(TMn) + O(TMn) + O(TMn) + O(TMn) =</math>

:<math> O(TMn) + O(M^2)</math>

'''II АЛГОРИТМ РАБОТЫ'''

1) Уровень набора функций

:<math>Complexity(SOMWorking) = </math>

:<math>T \cdot Complexity(ChooseInputVector) +</math>

:<math>T \cdot Complexity(InitialiseDistancesVector) +</math>

:<math>T \cdot K \cdot Complexity(CalculateDistanseBetweenInputVectorAndNeuronWeightsVector) +</math>

:<math>T \cdot K \cdot Complexity(PutCalculatedDistanceToDistancesVector) +</math>

:<math>T \cdot Complexity(FindNeuronWinner) +</math>

:<math>T \cdot Complexity(DefineInputVectorToCluster)</math>

2) Уровень реализации функций в рамках фундаментальных операций

Эквивалентно п.2 в Алгоритме обучения (но в качестве M у нас K).

:<math>Complexity(DefineInputVectorToCluster) = O(1)</math>

3) Конечная сложность

:<math>Complexity(SOMWorking) = O(Tn) + O(TKn) + O(TKn) + O(TKn) + O(TKn) + O(T) = O(TKn)</math>

== Информационный граф ==
[[Файл:InfGraph-1.png|500px|thumb|right|Рис. 3а.Информационный граф алгоритма обучения]]

В качестве операторных узлов информационного графа были выбраны:

• '''||a – b||''' - взятие евклидовой метрики от двух операндов

• '''FindMinimum''' – нахождение минимума из входящих значений

• '''UpdateWeights''' – обновление весов (для каждого входящего вектора отдельный узел)

• '''DefineCluster''' – определение кластера на основе полученного значения от нахождения минимума

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

Входные параметры алгоритма, для которого был построен информационный граф:

<math> N = 2</math> - размер обучающей выборки,

<math> K = 2</math> - размер тестовой выборки,

<math> a = 1</math> - высота слоя Кохонена,

<math> b = 2</math> - ширина слоя Кохонена,

Остальные параметры могут быть любыми, так как не оказывают влияние на построенный информационный граф.
[[Файл:InfGraphSOMSecond.png|500px|thumb|center|Рис. 3б.Информационный граф алгоритма работы]]

== Ресурс параллелизма алгоритма ==
Для того чтобы оценить насколько эффективно Алгоритм Кохонена параллелизуется, рассмотрим его структуру в виде последовательности этапов исполнения. Вначале рассмотрим алгоритм обучения. У нас есть 4 фундаментальных этапа:

[[Файл:SOMParallel.png|500px|thumb|right|Рис. 4.Пример параллельного алгоритма SOM при threadNumber = 2]]
1) '''Инициализация'''. На этом этапе мы определяем параметры алгоритма, рассчитываем расстояния между нейронами и определяем начальные веса нейронов. Здесь имеет смысл распараллелить подсчет метрики между нейронами. Таким образом асимптотическая сложность упадет с <math>O(M^2)</math> до <math>O(\frac{M^2}{threadNumber})</math>

2) '''Генерация подвыборки'''. Здесь мы определяем в каком порядке будем обрабатывать вектора исходного входного пространства, какой вектор возьмём для следующей итерации. К сожалению, эта стадия не поддается распараллеливанию, так как каждая итерация алгоритма зависит от предыдущей;

3) '''Поиск максимального подобия'''. Находим наиболее подходящий (победивший) нейрон, используя критерий минимума Евклидова расстояния. Этот этап распараллеливается следующим образом. Вначале мы рассчитываем метрику между вектором весов каждого нейрона и входящим вектором исходного пространства, для этого мы разбиваем количество нейронов <math>M</math> на <math>threadNumber</math> потоков и подсчитываем метрику в каждой группе нейронов на поток параллельно. Затем мы пользуемся фактом, что минимум – дистрибутивная функция (см. Рис. 4)

:<math>min([a, b, c, d]) = min(min([a, b]), min([b, c]))</math>

и рассчитываем её за <math>\log_{2} (threadNumber)</math> операций сравнения, что значительно меньше <math>M</math> в исходном варианте;

4) Коррекция. Корректируем векторы синаптических всех нейронов. Также очевидным образом распараллеливается на <math>threadNumber</math> потоков, в каждым из которых последовательно для каждого нейрона в группе внутри потока обновляются веса.

Итак, общая сложность параллельной версии алгоритма обучения

:<math>Complexity(SOMParallelLearning) = O(\frac{M^2}{threadNumber}) + </math>

:<math>O(\frac{TMn}{threadNumber} + \log_{2} (threadNumber)) + O(\frac{TMn}{threadNumber})</math>

что меньше последовательной (при <math>threadNumber \approx M</math>)

:<math>Complexity(SOMLearning) = O(M^2) + O(TMn) + O(TMn)</math>.

Алгоритм работы карты эквивалентен первым 3 уровням алгоритма обучения только с другими константами
(нужно заменить <math>M</math> на <math>K</math>, предварительно убрав слагаемое <math>O(M^2)</math>,
так как во время работы рассчитывать расстояние между нейронами не нужно).

'''Вывод''': Проведенный обзор показал, что только этап этап генерации подвыборки не поддается распараллеливанию. Это типичная проблема большинства алгоритмов машинного обучения, так как они итеративны (последовательно обучается по всей выборке). Однако в рамках остальных этапов алгоритм легко разбивается на потоки, что в теории улучшает производительность.

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

<math>n</math> - размерность исходного пространства,

<math> \chi \subset R^n</math> - обучающая выборка,

<math> \Phi \subset R^n </math> - тестовая выборка,

<math> N = |\chi|</math> - размер обучающей выборки,

<math> K = |\Phi|</math> - размер тестовой выборки,

<math> a </math> - высота слоя Кохонена,

<math> b </math> - ширина слоя Кохонена,

<math> T </math> - максимальное число итераций алгоритма обучения - может быть задано фиксировано, либо же равно мощности обучающей выборки, то есть <math> N </math>,

<math> h_{ij}(t)</math> - функция соседства между нейронами с индексами <math>i</math> и <math>j</math> на итерации t,

<math> h(d,t) </math> - функция от расстояния между нейронами,

<math> \alpha(t)</math> - скорость обучения сети,

<math> \sigma(t) </math> - функция, уменьшающая количество соседей с при увеличении итерации (монотонно убывающий).

Вычислительная сложность хранения входных данных для алгоритма обучения равна <math>O(n \times N)</math>
(установка функций и прочих параметров выполняется за константное время).

Вычислительная сложность хранения входных данных для алгоритма работы равна <math>O(n \times K)</math>.

'''Выходные данные алгоритма обучения:'''

<math>\vec{w}^{(j)}(t) = (w_1^{(j)}(t),...,w_n^{(j)}(t)), j = 1,..,M</math> - вектор весовых коэффициентов для <math>j</math>-го нейрона,

матрица <math>\mathbf{W}</math>, представляющая веса нейронов <math>\vec{w}^{(j)}(t)</math>
Вычислительная сложность хранения выходных данных равна <math>O(n \times M)</math>.

'''Выходные данные алгоритма работы''':

Вычислительная сложность хранения выходных данных равна <math>O(1)</math>, если алгоритм возвращает индекс кластера или координату нейрона,
иначе если возвращает вектор весов нейрона-победителя, то <math>O(n)</math>

== Свойства алгоритма ==
Итак, вычислительная мощность алгоритма кластеризации самоорганизующимися сетями Кохонена равна

:<math>ComputationalPower(SOM) = \frac{TMn + M^2}{Mn + Tn} = \frac{M(Tn + M)}{n(M + T)}</math>

Cоотношение последовательной и параллельной сложности алгоритма описано в п. 1.8

Детерминированность алгоритма зависит от способа генерации выборки из исходного входного пространства, если она
детерминирована, то и алгоритм детерминирован, иначе нет.

Общие свойства алгоритма:
*Аппроксимация входного пространства. Карта признаков, представленная множеством векторов синоптических весов, в выходном пространстве реализует хорошую аппроксимацию входного пространства.
*Топологический порядок. Карта признаков, полученная алгоритмом SOM, является топологически упорядоченной в том смысле, что пространственное положение нейронов в решетке соответствует конкретной области или признаку входного образа.
*Соответствие плотности. Карта признаков отражает вариации в статистиках распределения входного сигнала. Области во входном пространстве, из которого берутся векторы <math>\vec{x}</math> с большей вероятностью, отображаются в гораздо большие области выходного пространства и, таким образом, с большим разрешением, чем области в исходном пространстве, из которых берутся векторы <math>\vec{x}</math> с меньшей вероятностью.
*Выбор признаков. Для данных из входного пространства с нелинейным распределением самоорганизующаяся карта для аппроксимации исследуемого распределения способна извлечь набор наилучших признаков.

Преимущества алгоритма:

*Является устойчивым, в том числе и к зашумленным данным;
*Реализует быстрое и неуправляемое обучение (процесс самоорганизуюется);
*Может визуализировать многомерные входные данные (упрощения многомерных входных данных с помощью визуализации);
*Может аппроксимировать любую непрерывную функцию, что позволяет исследователю не принимать заранее какие-либо гипотезы относительно модели.

Недостатки алгоритма:

*Работает только с вещественными числовыми векторами;
*Может быть использован для кластерного анализа только в том случае, если заранее известно число кластеров;
*Наличие искажений. Близкие объекты исходного пространства могут переходить в далёкие точки на карте;
*Окончательный результат работы нейронных сетей сильно зависит от начальных установок сети (начальное распределение весов, свойства потенциальной функции).

= Программная реализация алгоритма =

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

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

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

== Масштабируемость алгоритма и его реализации ==
Вышеописанный алгоритм кластеризации был реализован с помощью технологии OpenMP и протестирован на суперкомпьютере Ломоносов.

Методология тестирования представляет из себя последовательные запуски:
* с размером решетки Кохонена (решетки нейронов) 10x10, 30x30, 50x50, 70x70,90x90,110x110;
* числом openmp_threads: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20;
* при размере входного пространства равном 4;
* для обучающей выборки размером 400000 (4-x мерных) векторов;
* для тестовой выборки размером 34874 (4-х мерных) вектора.

В результате было построено два графика (ссылки на интерактивные графики):
* [https://plot.ly/~crowslord/5.embed Зависимость времени работы обученной сети Кохонена от размера решетки Кохонена и числа openmp_threads];
* [https://plot.ly/~crowslord/7.embed Зависимость времени обучения сети Кохонена от размера решетки Кохонена и числа openmp_threads].

[[Файл:TrainSom.png]] [[Файл:WorkSom.png]]

При этом по фронтальной оси X откладывается количество openmp_threads, по оси Y откладывается одно измерение размера матрицы (то есть если матрица была 50x50, то по оси будет отложено 50, по оси Z откладывается время обучения сети Кохонена для первого графика и время работы сети Кохонена для второго графика.

Анализ графиков позволяет сделать вывод о том, что алгоритм хорошо масштабируем - по графикам видно, что время обучения/работы сети Кохонена резко возрастает при одновременном уменьшении количества openmp_threads и увеличении размера решетки Кохонена (то есть, в конечном счете, числе кластеров).

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

Также было установлено, что при использовании вложенного параллелизма время работы существенно увеличивается, поэтому значение OMP_NESTED = 0.

Параллелизм реализован на уровне openmp_threads в следующих блоках кода:
* расчет расстояний между нейронами в карте Кохохнена;
* начальная инициализация нейронов;
* поиск нейрона-победителя.

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

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

== Существующие реализации алгоритма ==

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

На данный момент удалось найти следующие последовательные реализации:

* [http://knnl.sourceforge.net/ KNNL]:Реализация на C++
* [https://pypi.python.org/pypi/kohonen kohonen] Реалиазция на Python
* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Реалиазция на R
* [http://jknnl.sourceforge.net/ JKNNL]: Реалиазция на Java.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реалиазция на Matlab.

Также есть параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Реализация на Python, R, Julia, и Matlab, поддерживаются OpenMP, MPI и CUDA.

= Литература =
* T. Kohonen, Self-Organizing Maps (Third Extended Edition), New York, 2001, 501 pages. ISBN 3-540-67921-9
* Нейский И.М. Классификация и сравнение методов кластеризации [[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf]]
* Хайкин С. Нейронные сети: полный курс, 2-е изд.: Пер. с англ. - М.:ООО "И. Д. Вильямс", 2016. - 1104с. ISBN 978-5-8459-2069-0 (рус.)
* К. В. Воронцов Лекции по искусственным нейронным сетям 21 декабря 2007 г.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-12-07T12:33:05Z

Teplov:

{{Assignment | Teplov}}

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

=== Последовательная сложность алгоритма ===

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

Опишем информационный граф алгоритма.

'''Первый этап''' состоит из <math>n</math> параллельных операций вычисления евклидового расстояния до случайно выбранного входного вектора.

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

Для алгоритма кластеризации сетями Кохонена средних имеет место массовый параллелизм: в основе каждого из основных этапов алгоритма (поиска евклидовых расстояний для определения нейрона-победителя и обновления весов) лежат информационно независимые действия.
Учитывая данный факт можно оценить параллельную сложность алгоритма в предположении доступности неограниченного числа необходимых процессоров.

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

Устойчивость к зашумленным данным, быстрое и неуправляемое обучение, возможность упрощения многомерных входных данных с помощью визуализации.
Главное преимущество самоорганизующихся карт Кохонена является их способность "проецирования" многомерных пространств на двумерное. Важной особенностью карт Кохонена является то, что объекты с похожими характеристиками (по всем компонентам) располагаются рядом, образуя кластеры.

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

==== Масштабируемость реализации алгоритма ====

Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета. Алгоритм был реализован с помощью языка Fortran 90.

Реализация тестировалась со следующими параметрами:

* число процессоров [1 : 128];
* размер входного слоя сети, а также слоя Кохонена (были установлены равными друг другу) [1000 : 4000].

[[Файл:Plot_s2.svg|thumb|600px|center| На рисунке представлен график зависимости времени выполнения от числа процессоров и размерности входных данных]]

[[Файл:Plot_s3.svg|thumb|600px|center| Производительность в зависимости от числа процессоров и размерности входных данных]]

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

Была использована следующая авторская реализация алгоритма.

program Kohonen
implicit none
include 'mpif.h'
integer rank,ierr,size,sizeBlock
integer n,perProc,i,j,k,jmin,jAbsWin
integer iterNum,IOS
real learning_rate
real dist,prom,minDist
real, allocatable :: W(:,:),sample(:,:),maswin(:,:)
real, allocatable :: buf(:,:),win(:)
double precision start,finish
character str

iterNum = 1000
n=1000

learning_rate = 1.0

allocate(W(n,n))
allocate(sample(iterNum,n))
allocate(win(2))

call randMatr(sample,iterNum,n,.FALSE.)
call randMatr(W,n,n,.True.)

call MPI_INIT(IERR)
call MPI_COMM_SIZE(MPI_COMM_WORLD,SIZE,IERR)
call MPI_COMM_RANK(MPI_COMM_WORLD,RANK,IERR)

perProc = n/size
allocate(buf(n,perProc))
allocate(maswin(2,size))
sizeBlock = perProc * n

if (rank .eq. 0) then
start = MPI_WTIME(IERR)
end if

do i=1,IterNum,1
call obnul(buf,n,perProc)
call MPI_SCATTER(W,sizeBlock,MPI_REAL,buf,sizeBlock,MPI_REAL,0,MPI_COMM_WORLD,IERR)

dist = euclDist(sample(i,1:n),buf(1:n,1),n)
do j=1,perProc,1
prom = euclDist(sample(i,1:n),buf(1:n,j),n)
if (prom .le. dist) then
dist = prom
jmin = j + rank*perProc
end if
enddo
win(1) = jmin
win(2) = dist

call MPI_BARRIER(MPI_COMM_WORLD,IERR)

call MPI_GATHER(win,2,MPI_REAL,maswin,2,MPI_REAL,0,MPI_COMM_WORLD,IERR)

if (rank .eq. 0) then
minDist = maswin(2,1)
jAbsWin = maswin(1,1)
do j=2,size,1
if (mindist .ge. maswin(2,j)) then
minDist = maswin(2,j)
jAbsWin = maswin(1,j)
endif
enddo
call modW(W,n,learning_rate,i,jAbsWin)
end if
enddo

if (rank .eq. 0) then
finish = MPI_WTIME(IERR)
open(1,file="Rezult.txt",iostat=IOS)
do while (.NOT. eof(1))
read(1,*) str
enddo
write (1,*) 'Neurons: ',n,'Processes: ',size,'Time: ',finish-start
close(1)
end if

call MPI_FINALIZE(IERR)

!call printm(W,n,n)

deallocate(W,sample,win,maswin,buf)

contains

subroutine printm(W,a,b)
integer a,b,i,j
real W(n,n)

do j=1,b,1
write(*,*)(W(i,j), i=1,a)
enddo
end subroutine printm

subroutine obnul(W,a,b)
integer a,b
integer i,j
real W(a,b)

do j=1,b,1
do i=1,a,1
W(i,j) = 0.0
enddo
enddo
end subroutine obnul

real function euclDist(a,b,n)
integer n,i
real a(n),b(n),res

res = 0
do i = 1,n,1
res = res + (a(i) - b(i)) * (a(i) - b(i))
enddo

euclDist = sqrt(res)
end function euclDist

subroutine modW(W,n,learning_rate,iter,jAbsWin)
integer n,iter,JAbsWin
real learning_rate,W(n,n)
integer i,j

do j=1,n,1
if (j .ne. jAbsWin) then
do i=1,n,1
W(i,j) = W(i,j) + learning_rate/sqrt(iter+1.0)*(W(i,jAbsWin)-W(i,j))
enddo
end if
enddo
end subroutine modW

subroutine randMatr(matr,a,b,small)
integer a,b
logical small
integer i,j
real matr(a,b),x

do j=1,b,1
do i=1,a,1
call random_seed
call random_number(x)
x = x * 10 - x * 8
if (small) then
x = x / 40
end if
matr(i,j) = x
enddo
enddo
end subroutine randMatr
end program Kohonen

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

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

2016-11-22T12:10:11Z

Teplov: /* Замечания */

== Участники:Потапов Юрий Скрипник Артур/Алгоритм концептуальной кластеризации COBWEB ==

=== Замечания ===
* не указан вклад авторов [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* лучше выделить формулы в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* использованы не очень наглядные графы часто мелкие и плохо читаемые [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* не указано для каких параметров построены графы [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* нет оценок объема входных и выходных данных [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* в п. 1.10 нет оценки вычислительной мощности алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:09, 23 октября 2016 (MSK)
* отсутствуют данные по численным экспериментам и масштабируемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:10, 22 ноября 2016 (MSK)

Обсуждение участника:Мязина Екатерина

2016-11-22T12:08:55Z

Teplov: /* Замечания */

== Статья [[Участник:Мязина Екатерина/Алгоритм концептуальной кластеризации COBWEB]] ==

=== Замечания ===
* отсутствует список литературы [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* отсутствует указание автора в статье [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* текст нужно больше структурировать, формулы выделить. Читаемость текста очень низкая [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* граф очень мелкий, непонятный [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* рисунки не подписаны и не пронумерованы [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* в кратких свойствах необходимо указать не только последовательную сложность [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* необходимо указать для каких параметров построен граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* отсутствует п. 1.10 [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:55, 23 октября 2016 (MSK)
* отсутствуют данные оп численному эксперименту и масштабируемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:08, 22 ноября 2016 (MSK)

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

2016-11-22T12:07:39Z

Teplov: /* Замечания */

== Статья [[Участники: Круглов Леонид, Баранов Максим/Алгоритм устойчивой кластеризации с использованием связей]] ==

=== Замечания ===
* формулы нужно оформить в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:39, 23 октября 2016 (MSK)
* необходимо указать на каком языке приведен код [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:39, 23 октября 2016 (MSK)
* необходимо указать для каких параметров построен граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:39, 23 октября 2016 (MSK)
* в п. 1.10 необходимо явно указать вычислительную мощность алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:39, 23 октября 2016 (MSK)
* отсутствует краткая сводка свойств алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:14, 23 октября 2016 (MSK)

* необходимо в п.2.4 провести анализ масштабируемости алгоритма. Описать конфигурации запуска и т.п. Эксперименты провести с изменением числа процессоров/потоков/процессов и размера задачи. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:07, 22 ноября 2016 (MSK)
* результаты анализа необходимо представить в виде наглядного графика. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:07, 22 ноября 2016 (MSK)

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

2016-11-22T12:05:46Z

Teplov:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Get_processor_name(hostname, &len);
printf ("Number of tasks= %d My rank= %d Running on %s\n", numprocs, rank, hostname);

size_t msize = m_adjacency_matrix.size();
unsigned num_tasks = msize / numprocs;
unsigned delta = msize % numprocs;
MPI_Request reqs[msize];
MPI_Status stats[msize];

if (rank == 0) {
// Initialize async receives for rows computed at other nodes
for (size_t r = 1; r != numprocs; r++) {
for (size_t i = num_tasks*r; i < num_tasks*(r + 1); i++) {
MPI_Irecv(&(m_adjacency_matrix.raw_data()[i][0]), msize, MPI_DOUBLE, r, MPI_ANY_TAG, MPI_COMM_WORLD, reqs + i);
}
}
}

// compute what is needed
for (size_t i = num_tasks*rank; i < num_tasks*(rank + 1); i++) {
for (size_t j = 0; j < msize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);

if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}
if (rank == 0) {
// finish is there's anything left
for (size_t i = num_tasks * numprocs; i != msize; i++) {
for (size_t j = 0; j < msize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);

if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}
MPI_Waitall(msize, reqs, stats);
} else {
// send the data to node 0
for (size_t i = num_tasks*rank; i < num_tasks*(rank + 1); i++) {
MPI_Isend(&(m_adjacency_matrix.raw_data()[i][0]), msize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, reqs + i);
}
}
MPI_Finalize();
}
</source>

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

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

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

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

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

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

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

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

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

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

2016-11-22T12:05:30Z

Teplov:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Get_processor_name(hostname, &len);
printf ("Number of tasks= %d My rank= %d Running on %s\n", numprocs, rank, hostname);

size_t msize = m_adjacency_matrix.size();
unsigned num_tasks = msize / numprocs;
unsigned delta = msize % numprocs;
MPI_Request reqs[msize];
MPI_Status stats[msize];

if (rank == 0) {
// Initialize async receives for rows computed at other nodes
for (size_t r = 1; r != numprocs; r++) {
for (size_t i = num_tasks*r; i < num_tasks*(r + 1); i++) {
MPI_Irecv(&(m_adjacency_matrix.raw_data()[i][0]), msize, MPI_DOUBLE, r, MPI_ANY_TAG, MPI_COMM_WORLD, reqs + i);
}
}
}

// compute what is needed
for (size_t i = num_tasks*rank; i < num_tasks*(rank + 1); i++) {
for (size_t j = 0; j < msize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);

if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}
if (rank == 0) {
// finish is there's anything left
for (size_t i = num_tasks * numprocs; i != msize; i++) {
for (size_t j = 0; j < msize; j++) {
double distance = euclidean_distance_sqrt(&p_data[i], &p_data[j]);

if (distance < m_radius) {
m_adjacency_matrix.set_connection(i, j);
}
}
}
MPI_Waitall(msize, reqs, stats);
} else {
// send the data to node 0
for (size_t i = num_tasks*rank; i < num_tasks*(rank + 1); i++) {
MPI_Isend(&(m_adjacency_matrix.raw_data()[i][0]), msize, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, reqs + i);
}
}
MPI_Finalize();
}
</source>

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

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

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

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

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

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

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

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

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

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

2016-11-22T12:02:43Z

Teplov: /* Замечания */

== Статья [[Участник:Иванов Даниил/Алгоритм устойчивой кластеризации с иcпользованием связей]] ==

=== Замечания ===
* Отсутствуют разделы с реализациями алгоритма и списком литературы [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* Формулы необходимо выделить в отдельные блоки, так же везде проверить корретность тегов. Встречается кривое описание математических выражений типа math>i</math> [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* Граф совем не читаем, необходимо переработать и масштаб и структуру. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* Необходимо указать автора статьи в тексте. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* п. 1.5 указать язык кода [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* п. 1.7 необходимо указать для каких параметров создан граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* п. 1.8 необходимо расписать значительно более подробно и обосновать почему получены такие значения [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* п. 1.9 необходимо оценить объемы значений [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* п. 1.10 нужна вычислительная мощность алгоритма. Сложность - другие пункты. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:26, 23 октября 2016 (MSK)
* отсутствует краткая сводка свойств алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:14, 23 октября 2016 (MSK)
* отсутствуют данные по численным экспериментам и масштабируемости. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:02, 22 ноября 2016 (MSK)

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

2016-11-22T12:01:30Z

Teplov: /* Замечания */

== Статья [[Участник:Viktorrulev/Алгоритм устойчивой кластеризации с иcпользованием связей]] ==

=== Замечания ===
* Формулы нужно оформить в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:13, 23 октября 2016 (MSK)
:: Исправлено (сделать все формулы в одном блоке и выровнять по левой стороне вики не позволяет) [[Участник:Viktorrulev|Viktorrulev]] ([[Обсуждение участника:Viktorrulev|обсуждение]]) 12:18, 26 октября 2016 (MSK)
* В п. 2.7 необходимо указать ссылку на источник [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:13, 23 октября 2016 (MSK)
:: Исправлено [[Участник:Viktorrulev|Viktorrulev]] ([[Обсуждение участника:Viktorrulev|обсуждение]]) 12:18, 26 октября 2016 (MSK)
* В п. 1.5 указать на каком языке представлена реализация [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:13, 23 октября 2016 (MSK)
:: Исправлено [[Участник:Viktorrulev|Viktorrulev]] ([[Обсуждение участника:Viktorrulev|обсуждение]]) 12:18, 26 октября 2016 (MSK)
* В п. в п. 1.7 не указано для каких параметров построен граф. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:13, 23 октября 2016 (MSK)
:: Исправлено [[Участник:Viktorrulev|Viktorrulev]] ([[Обсуждение участника:Viktorrulev|обсуждение]]) 12:18, 26 октября 2016 (MSK)
* Нужно более полное описание вычислительной мощности алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 01:13, 23 октября 2016 (MSK)
:: Дополнено [[Участник:Viktorrulev|Viktorrulev]] ([[Обсуждение участника:Viktorrulev|обсуждение]]) 12:18, 26 октября 2016 (MSK)

* Отсутствуют данные по численному эксперименту и масштабируемости. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 15:01, 22 ноября 2016 (MSK)

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

2016-11-22T12:01:00Z

Teplov:

{{algorithm
| name = Алгоритм устойчивой кластеризации с иcпользованием связей
| serial_complexity = <math>O(M^2 + M^2m_{nbr} + M^{2}logM)</math>
| pf_height = <math>O(MlogM)</math>
| pf_width = <math>O(M^2)</math>
| input_data = <math>M \times N</math>
| output_data = <math>M</math>
}}

Автор описания: [[Участник:viktorrulev|В.А. Рулев]].

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

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

Кластеризация (кластерный анализ) — задача разбиения заданной выборки объектов на непересекающиеся подмножества, называемые кластерами, так, чтобы каждый кластер состоял из схожих объектов, а объекты разных кластеров существенно отличались. Каждый объект из выборки характеризуется рядом признаков, которые могут быть вещественными, целочисленными, категорийными (то есть принимающими значения из какого-либо множества) и другими. Множество значений, которые может принимать признак, называется доменом этого признака. Так, например, у объекта '''кошка''' может быть категорийный признак '''порода''', доменом которого является множество '''[персидская, бенгальская, сфинкс, мейн-кун, ...]'''.

'''Алгоритм устойчивой кластеризации с иcпользованием связей (robust clustering using links, ROCK)''' был предложен в 2000 году Sudipto Guha (Stanford University), Rajeev Rastogi (Bell Laboratories) и Kyuseok Shim (Bell Laboratories) <ref>Sudipto Guha, Rajeev Rastogi, Kyuseok Shim ROCK: A robust clustering algorithm for categorical attributes. 2000. Information Systems. Vol 25, Issue 5, Pages 345-366</ref> для кластеризации объектов с категорийными признаками.

Алгоритм устойчивой кластеризации с использованием связей предназначен для работы с объектами типа "транзакция" ("покупательская корзина"). Транзакция представляет собой множество товаров, приобретенных покупателем у поставщика. Каждому товару, который есть в наличии у поставщика, в транзакции соответствует отдельный признак, который принимает значение '''true''', если товар присутствует в транзакции, и '''false''', если товар в транзакции отсутствует.

=== Математическое описание алгоритма ===

В ходе кластеризации <math>M</math> имеющихся транзакций <math>P=\{p_1,...,p_M\}</math> (каждая транзакция имеет <math>N</math> признаков) должны быть разделены на <math>K</math> непересекающихся подмножеств (кластеров) <math>C_1, ..., C_K</math> таким образом, чтобы полученные кластеры максимизировали некоторую критериальную функцию <math>E(C_1, ..., C_K)</math>.

Будет называть две транзакции <math>p_1</math> и <math>p_2</math> '''соседями''', если мера сходства <math>neighbour(p_1,p_2)</math> этих транзакций больше некоторого заранее заданного порогового значения <math>\theta</math> В качестве меры сходства в алгоритме устойчивой кластеризации с использованием связей используется основанная на коэффициенте Жаккара мера сходства <math>sim(p_1,p_2)</math>. В ней <math>N(C_i)^{1+2f(\theta)}</math> имеет смысл ожидаемого (среднего) количества связей внутри одного кластера.

'''Количеством связей''' <math>link(p_1,p_2)</math> между двумя транзакциями <math>p_1</math> и <math>p_2</math> будем называть количество общих соседей этих транзакций.

Для того, чтобы сформировать кластеры, удовлетворяющие поставленному условию, необходимо последовательно объединять среди имеющихся кластеров такие пары кластеров, для которых метрика <math>goodness(C_i,C_j)</math> достигает максимального значения среди всех пар кластеров. На начальном этапе каждая транзакция считается отдельным кластером.

Формулы метода:
:<math>
neighbour(p_1,p_2)=(sim(p_1,p_2)>\theta)
</math>
 
:<math>
sim(p_1,p_2)=\frac{N(p_1 \cap p_2)}{N(p_1 \cup p_2)}
</math>
 
:<math>
link(p_1,p_2)=N \Big( \{ p \in P | sim(p_1,p) < \theta \} \cap \{ p \in P | sim(p_2,p) < \theta \} \Big)
</math>
 
:<math>
E(C_1,...,C_K)=\sum_{i=1}^{K}N(C_i) \ast \sum_{p_q,p_r \in C_i}\frac{link(p_q,p_r)}{N(C_i)^{1+2f(\theta)}}
</math>
 
:<math>
f(\theta)=\frac {1-\theta}{1+\theta}
</math>
 
:<math>
goodness(C_i,C_j)=\frac {\sum_{p_r \in C_i, p_q \in C_j}{link(p_r,p_q)}} {(N(C_i) + N(C_j))^{1+2f(\theta)} - N(C_i)^{1+2f(\theta)} - N(C_j)^{1+2f(\theta)}}
</math>

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма можно разделить на два основных этапа:

# Вычисление количества связей между каждой парой транзакций (<math>\frac {M \times M} {2}</math> вычислений количества связей)
# Последовательные объединения пар наиболее подходящих кластеров (<math>M-K</math> поисков пар и объединений)

Подробнее оба этапа будут описаны ниже.

=== Макроструктура алгоритма ===

На макроуровне можно выделить следующие шаги алгоритма:

'''Шаг 1:''' вычисление соседних транзакций.

'''Шаг 2:''' вычисление количества связей между всеми транзакциями.

'''Шаг 3:''' построение для каждого кластера упорядоченного списка значений метрики goodness со всеми остальными кластерами

'''Шаг 4:''' построение общего упорядоченного списка значений метрики goodness

'''Шаг 5 (повторяется то тех пор, пока количество кластеров не достигнет желаемого)'''

'''Шаг 5.1:''' объединение двух кластеров с наилучшим goodness

'''Шаг 5.2:''' обновление списков кластеров

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

Ниже приведен псевдокод схемы реализации последовательного алгоритма:

<source lang="pascal">
procedure compute_links(P)
begin
for each p[i], p[j] in P do
if sim(p[i], p[j]) > theta
is_neighbour[i, j] = true
else
is_neighbour[i, j] = false

links[i, j] = 0
for each p[i], p[j] in P do
for p[k] in P do
if is_neighbour[i, k] && is_neighbour[j, k]
links[i, j] = links[i, j] + 1
end

procedure cluster(P, k)
begin
links := compute_links(P)

for each p in P do
q[p] := build_local_list(links, p)
Q := build global_list(P, q)

while size(Q) > k do
begin
u := extract_max(Q)
v := extract_max(q[u])
w := merge(u, v)
delete(Q, v)

for each x in (q[u] or q[v]) do
begin
delete(q[x], u);
delete(q[x], v)
insert(q[x], w, goodness(x, w))
insert(q[w], x, goodness(x, w))
update(Q, x, q[x])
end

insert(Q, w, q[w])
deallocate(q[u])
deallocate(q[v])
end
end
</source>

=== Последовательная сложность алгоритма ===

Рассмотрим сложности шагов алгоритма из раздела 1.4.

'''Шаг 1:''' выполняется с помощью двух вложенных циклов и содержит <math>O(M^2)</math> операций

'''Шаг 2:''' задача сводится к умножению полученной на предыдущем шаге матрицы соседства на саму себя. Это действие быть выполнено с помощью наивного метода за <math>O(M^3)</math> операций. С помощью алгоритма Копперсмита — Винограда это можно сделать за <math>O(M^{2.37})</math> операций.<ref>Donald Coppersmith and Shmuel Winograd. Matrix multiplication via arithmetic progressions. In Proc. of the 19th Annual ACM Symposium on Theory of Computing. 1987.</ref> В случае, если среднее количество соседей каждой транзакции значительно меньше общего количества транзакций, связи могут быть вычислены за <math>O(M^2m_{nbr})</math>, где <math>m_{nbr}</math> - среднее количество соседей транзакции.

'''Шаг 3:''' имеет сложность <math>O(M)</math>.<ref>Thomas H. Cormen, Charles E. Leiserson, and Ronald L. Rivest. Introduction to
Algorithms. The MIT Press, Massachusetts, 1990.</ref>

'''Шаг 4:''' имеет такую же вычислительную сложность, как и предыдущий шаг.

'''Шаг 5:''' вычислительная сложность каждой итерации цикла составляет <math>O(MlogM)</math>, так как в худшем случае в ходе итерации выполняется <math>M</math> вставок элемента в упорядоченный список. Желаемое количество кластеров <math>K</math> мало по сравнению с <math>M</math>, следовательно можно считать, что нужно выполнить <math>M</math> итераций цикла. Таким образом, общая вычислительная сложность цикла равна <math>O(M^{2}logM)</math>.

Таким образом, общую последовательную сложность алгоритма в общем случае можно оценить, как

:<math>O(M^2 + M^{2.37} + M^{2}logM)</math>

или в случае небольшого количества соседних транзакций, как

:<math>O(M^2 + M^2m_{nbr} + M^{2}logM)</math>.

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

''Информационный граф перемножения плотных матриц с подробным описанием представлен в статье [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|перемножение плотных матриц]]''

Ниже представлен информационный граф наиболее интересного для рассмотрения этапа алгоритма устойчивой кластеризации с использованием связей - тела цикла (полупрозрачным показана следующая итерация цикла) при <math>n=5</math>.

[[file:Rock-graph.png|thumb|center|1000px|Рисунок 1. Граф тела цикла; merge - объединение кластеров, insert - вставка goodness с новым кластером в упорядоченные списки соответствующих кластеров.]]

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

'''Шаг 1:''' каждая итерация цикла может быть выполнена независимо от всех остальных. Таким образом, в этом случае ширина ЯПФ равна <math>O(M^2)</math>, а высота - <math>O(1)</math>.

'''Шаг 2:''' высота ЯПФ равна <math>O(M)</math>, а ширина - <math>O(M^2)</math> (''см. [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|перемножение плотных матриц]]'')

'''Шаг 3:''' имеет небольшую асимптотическую сложность, может быть выполнен последовательно.

'''Шаг 4:''' аналогично шагу 3.

'''Шаг 5:''' каждая итерация цикла может быть выполнена только после полного завершения предыдущей, а внутри каждой отдельной итерации все вставки могут быть выполнены независимо друг от друга. Следовательно ширина ЯПФ в этом случае равна <math>O(M)</math>, а высота ЯПФ равна <math>O(MlogM)</math>.

Таким образом, высота ЯПФ зависит от размерности задачи как <math>O(MlogM)</math>, а ширина ЯПФ - как <math>O(M^2)</math>.

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

'''Входные данные''': информация об <math>M</math> транзакциях, каждая их которых имеет <math>N</math> бинарных атрибутов.

'''Объём входных данных''': <math>M \times N</math> бинарных переменных. В силу того, что обычно в большинстве случаев лишь небольшое количество атрибутов транзакции имеет значение "1", каждую транзакцию можно хранить в виде списка номеров атрибутов, значения которых равны "1".

'''Выходные данные''': <math>K</math> кластеров.

'''Объём выходных данных''': <math>M</math> индексов транзакций, распределенных в <math>K</math> списков.

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

Вычислительная сложность последовательного алгоритма в общем случае равна <math>O(M^{2.37})</math>, а в случае небольшого количества соседних транзакций у каждой транзакции сложность равна <math>O(M^{2})</math>.

Вычислительная мощность алгоритма (соотношение количества операций к объему входных и выходных данных) в общем случае равна O(M^{1.37}), в а случае небольшого количества соседних транзакций (то есть в том случае, для которого и разрабатывался алгоритм) вычислительная мощность линейна.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как показано выше, является квадратичным.

== Программная реализация алгоритма ==

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

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

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

=== Масштабируемость алгоритма и его реализации ===

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

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

=== Существующие реализации алгоритма ===

Алгоритм устойчивой кластеризации с иcпользованием связей реализован в пакете CBA языка R.<ref>https://en.wikibooks.org/wiki/Data_Mining_Algorithms_In_R/Clustering/RockCluster</ref>

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

<references \>

Участник:Tikhomirov.mm/Алгоритм устойчивой кластеризации с иcпользованием связей (robust clustering using links, ROCK)

2016-11-22T11:59:04Z

Teplov:

{{Assignment|Teplov}}
{{algorithm
| name = Алгоритм устойчивой кластеризации с использованием связей
| serial_complexity = <math> O(n^2 + n m_m m_a + n^2 \log{} n)</math>
| input_data = Множество <math>S</math> из <math>n</math> элементов, число кластеров <math>k</math>
| output_data = <math>n</math> точек с метками <math>k</math> кластеров
}}
Основные авторы описания: [[Участник:Простов В. А.|В.А.Простов]](1.1 - 1.6, 1.9, 2.4), [[Участник:Tikhomirov.mm|М.М.Тихомиров]](1.7, 1.8, 1.10, 2.4, 2.7)

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Алгоритм устойчивой кластеризации с иcпользованием связей ROCK (RObust Clustering using linKs)''' был совместно разработан Sudipto Guha, Rajeev Rastogi и Kyuseok Shim при работе в Bell Laboratories. Впервые алгоритм был опубликован в 1999 году в статье под названием "ROCK: A Robust Clustering Algorithm for Categorical Attributes", входящей в "ICDE '99 Proceedings of the 15th International Conference on Data Engineering".

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

Одним из основных понятий для алгоритма ROCK является соседство двух точек. Пусть нам дана функция схожести <math> sim(p_i,p_j) </math>, принимающая значения от 0 до 1, которая выражает схожесть или близость объектов(точек) <math>p_i</math> и <math>p_j</math>. Предполагается, что 1 соответствует абсолютной близости, и 0 - наоборот. Тогда при некоторой границе <math>\theta</math> между 0 и 1, если <math> sim(p_i,p_j) \geq \theta </math>, то <math>p_i</math> и <math>p_j</math> будут соседними точками. Выбор Функции <math> sim(p_i,p_j) </math> и граничного значения <math>\theta</math> зависит входных данных и особенности реализации.

Вторым ключевым понятием являются связи. Функция связи <math> link(p_i,p_j) </math> определяется как количество общих соседей у <math>p_i</math> и <math>p_j</math>. Из такого определения сразу видно, что чем больше значение связи, тем больше вероятность, что эти точки принадлежат одному и тому же кластеру. Такой подход является более глобальным, по сравнению с использованием только близости двух точек, что позволяет снизить число ошибок, особенно в тех случаях, когда кластеры имеют несколько близких точек.

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

== Математическое описание алгоритма ==

Дано множество <math> S </math> из <math> n </math> элементов и число <math> k </math>. Для каждых <math> p_i,p_j \in S </math> задана функция схожести <math> 0 \leq sim(p_i,p_j) \leq 1</math>. Также дано число <math> 0 \leq \theta \leq 1</math>. Дана функция <math> f( \theta ) </math>.

Требуется разбить <math> S </math> на <math> k </math> не пересекающихся подмножеств(кластеров) <math>C_1, \dots, C_k</math> так, чтобы значение целевой функции <math>E_l</math>было как можно большим.

Определим следующие функции, полагая, что <math> p_i,p_j \in S. </math>

Функция, определяющая соседство двух точек:

:<math>
\begin{align}
neib(p_i, p_j) = \begin{cases}
1, sim(p_i, p_j) \geq \theta,\\
0, sim(p_i, p_j) < \theta.
\end{cases} \\

\end{align}
</math>

Функция, определяющая количество связей между точками:

:<math>
link(p_i, p_j) = \sum_{s\in S} neib(p_i,s) neib(p_j,s).
</math>

Определим теперь целевую функцию, считая <math>n_i</math> количеством элементов в <math>C_i</math>:

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

Определим функцию связи для двух подмножеств <math> C_i, C_j </math>:

:<math>
link[C_i, C_j] = \sum_{p_q \in C_i, p_r \in C_j} link(p_i, p_j)
</math>

Введем функцию полезности, выражающую то, насколько выгодно объединить подмножества <math> C_i, C_j </math>:

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

В данном алгоритме сначала все элементы разбиваются на <math> n </math> подмножеств, затем делается <math> n - k </math> шагов, на каждом из которых объединяются два подмножества, для которых значение функции полезности <math> g(i,j) </math> наибольшее.

== Вычислительное ядро алгоритма ==

Вычислительное ядро алгоритма состоит из двух основных частей.

1. Вычисление всех связей между точками. Для каждой точки создается список соседей. Проходим по каждому такому списку и увеличиваем количество связей между всеми точками из списка, поскольку они имеют общую соседнюю точку (ту, которой принадлежит список).

2. Цикл по объединению кластеров, содержит <math> n-k </math> шагов, на каждом из которых мы находим наилучшие кластеры для объединения и перестраиваем соответствующие кучи.

== Макроструктура алгоритма ==

Как написано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], алгоритм состоит из двух основных частей: Вычисление связей и Объединение кластеров.

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

Процедура кластеризации выглядит следующим образом:

procedure cluster(S, k)
begin
link := compute_links(S)
for each s <math>\in</math> S do
q[s] := build_local_heap(link, s)
Q := build_global_heap(S, q)
while size(Q) > k do {
u := extract_max(Q)
v := max(q[u])
delete(Q, v)
w := merge(u, v)
for each x <math>\in</math> q[u] <math>\cup</math> q[v] do {
link[x,w] := link[x, u] + link[x, v]
delete(q[x], u); delete(q[x], v)
insert(q[x],w, g(x,w)); insert(q[w], x, g(x,w))
update(Q, x, q[x])
}
insert(Q,w, q[w])
deallocate(q[u]), deallocate(q[v])
}
end

1. Вычисление связей между каждой парой точек:

procedure compute_links(S)
begin
Compute nbrlist[i] for every point i in S
Set link[i, j] to be zero for all i, j
for i := 1 to n do {
N := nbrlist[i]
for j := 1 to |N| - 1 do
for l := j + 1 to |N| do
link[N[j],N[l]] := link[N[j],N[l]] + 1
}
end

Дла каждой точки <math>i</math> строится список соседей <math>nbrlist[i]</math>. Поскольку любые две точки в таком списке имеют nbrlist[i] в качестве общего соседа, то для всех пар точек из списка увеличиваем значение функции связей.

2. Каждая точка объявляется отдельным кластером. Для каждого кластера <math>i</math> строится локальная куча <math>q[i]</math>, которая поддерживается до конца работы алгоритма. <math>q[i]</math> содержит все такие кластеры <math>j</math>, что <math>link[i,j] \neq 0</math>. Кластеры <math>j</math> в <math>q[i]</math> отсортированы в порядке убывания функции полезности <math>g(i,j)</math>. Аналогичным образом создается глобальная куча <math>Q</math>, содержащая все кластеры. Элементы внутри аналогично отсортированы в соответствии с их максимальным значением функции полезности.

3. Запускается while-цикл до тех пор, пока количество кластеров не станет равно <math>k</math>. На каждом шаге цикла берутся два кластера с максимальным значением <math>g(i,j)</math> и объединяются. Из глобальной кучи извлекается максимум, затем для этого кластера из его локальной кучи также извлекается максимум. По построению куч легко видеть, что это будет искомой парой. Далее происходит объединение кластеров, после чего для каждого кластера, который содержал в своей локальной куче один из данных, необходимо провести соответствующую коррекцию. Из глобальной кучи также удаляются два элемента и добавляется один новый с сохранением порядка.

== Последовательная сложность алгоритма ==

Вычисление связей может рассматриваться как перемножение двух матриц размера <math? n </math>, что можно реализовать за <math> O(n^{2.37})</math>. Затраты памяти на хранение связей не превышают <math> n(n+1)/2 </math>, когда любая пара точек - соседние. Однако в большинстве случаев среднее число соседей <math> m_a </math> и максимальное число соседей <math> m_m </math> значительно меньше <math> n </math>, в связи с этим оценки сложности зависят от данных параметров. Сложность построения списка соседей оценивается <math> O(n^2)</math>, Вычисление связей состоит из трех вложенных циклов и может быть оценено <math> O(n m_m m_a)</math>. Поскольку каждая точка <math>i</math> может иметь не более <math>\min \{ m_m m_i, n \} )</math> связей, то общие затраты памяти не превышают <math> O(\min \{ n m_m m_a, n^2 \} )</math>.

Построение каждой кучи потребует не более <math> O(n)</math> времени (поскольку размер каждой кучи не может превышать <math> n </math>) Сортировка каждой кучи потребует <math> O( n \log{} n)</math>. Рассмотрим теперь основной while-цикл. Он содержит <math> O(n)</math> итераций, где основная сложность каждого шага приходится на for-цикл. В худшем случае потребуется вставить новый кластер в <math> O(n)</math> локальных куч размера <math> n</math>, что потребует <math> O( n \log{} n)</math> времени. Таким образом, сложность всего внешнего цикла составляет <math> O(n^2 \log{} n)</math> в худшем случае. Затраты памяти зависят от начального размера локальных куч, поскольку при слиянии кластеров их старые кучи удаляются, а размер новой не превышает суммы старых. Поскольку каждая куча сожержит лишь кластеры с ненулевыми связями, то сложность совпадает с первой частью и равна <math> O(\min \{ n m_m m_a, n^2 \} )</math>.

Итоговые оценки для всего алгоритма:

'''Сложность по времени''':

:<math> O(n^2 + n m_m m_a + n^2 \log{} n)</math>

'''Сложность по памяти''':

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

== Информационный граф ==
[[Файл:Graph_tikh.png|400px|thumb|рис 1. Граф в общем виде для n точек и k кластеров.]]
Обозначения :
* '''CN''' - вершина построения соседей: заполнение nbrlist[i].
* '''CLM''' - вершина построения матрицы связей: заполнение link[i][j].
* '''CLH''' - вершина построения локальных куч: заполнение q[i].
* '''CGH''' - вершина построения глобальной кучи: заполнение Q.
* '''GC''' - вершина поиска и слияние топ 2 кластеров: построение w.
* '''RL''' - пересчет матрицы связей: заполнение link[x,w].
* '''UPDATE''' - Обновление глобальной кучи: обновление Q.

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

1) Вершина построения матрицы links. Данные вычисления не могут быть прямо распараллелены, нельзя для каждого списка соседей запустить данную функцию. Это связано с тем, что во время выполнения данных вычислений необходимо производить запись в матрицу и любой список может писать в любое место матрицы. В худшем случае (когда все соседи всем) при параллельном запуске возможны постоянные конфликты. Но в данной вершине все же есть потенциал для параллельной работы. Он заключается в том, что можно в параллели обрабатывать список соседей. При подходе в лоб нагрузка на ядра будет не равномерна.

Так же данный пункт можно реализовать иначе. Но затраты по памяти возрастут в N раз. Можно параллельно обрабатывать каждый вектор соседей. При среднем количестве соседей <math>m_a</math> это займет <math>O(m_a ^ 2)</math> операций (или если мы имеем <math>n^2</math> ядер, то можно и за <math>O(m_a)</math> + <math>O(log(n))</math> для объединения N матриц.

2) Вершина построения глобальной кучи. В данной вершине необходимо добавить все вершины и после отсортировать в зависимости от наилучшего значения полезности каждой локальной кучи. Сортировку можно распараллелить.

3) Вершина взятия топ 2 кластеров. Узкая, но малозатратная вершина.

4) Вершина обновления куч. Так же узкая вершина в которой нужно в каждой локальной куче вставить в нужное место кластер и так же поступить с глобальной кучей.

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

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

1) На первом этапе происходит вычисление соседей. Затраты данных операций при условии достаточного количества ядер <math>T_1 = O(n)</math>

2) На этапе построения связей <math>n</math> этапов в каждом из которых можно сделать <math>m</math> расчетов(с учетом распараллеливания), где <math>m</math> - количество соседей. В худшем случае <math>T_2 = O(n^2)</math> в среднем случае <math>T_2 = O(n * m_a)</math>, где <math>m_a</math> среднее ожидаемое число соседей.

3) Построение одной кучи это сложность <math>O(n)</math>. Плюс для каждой кучи сортировка <math>O(n * log(n))</math>. Соответственно итоговая сложность создания локальных куч <math>T_3 = O(n * log(n))</math>.

4) Построение и сортировка глобальной кучи так же <math>T_4 = O(n * log(n))</math>.

5) Цикл в котором происходит выбор кластеров, сливание, пересчет и обновление куч. Игнорируем выбор кластеров (достать из кучи <math>O(1)</math> ). Для всех элементов кучи слитых кластеров пересчитываем значение связи, вставляем в кучу выбранного кластера информацию о новом кластере, удаляем старое. Делается это за <math>O(log(n))</math>. Соответственно в худшем случае, одна итерация цикла это <math>T_i = O(log(n))</math>.
Количество итераций n - k. Значит

:<math>T_5 = O((n - k) * log(n))</math>. При k = 1, <math>T_5 = O(n * log(n))</math>

Итоговая сложность в худшем случае равна:

:<math>T_1 + T_2 + T_3 + T_4 + T_5 = O(n) + O(n^2) + O(n * log(n)) + O(n * log(n)) + O(n * log(n)) = O(n^2)</math>

Итоговая сложность в среднем случае равна:

:<math>O(n * m_a) + O(n * log(n))</math>.

Тут важно понимать, что в зависимости от данных как <math>log(n)</math> может быть больше <math>m_a</math>, так и наоборот.

Сложность по времени:

:<math>O(n * (m_a + log(n)))</math>.

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

'''Входные данные:''' Множество <math>S</math> из <math>n</math> элементов, число кластеров <math>k</math>. В зависимости от реализации, некоторые параметры алгоритма могут также подаваться на вход или быть определены заранее.

'''Объем входных данных:''' Зависит от типа элементов из множества <math>S</math>, поскольку алгоритм может быть реализован для широкого класса данных. В общем случае требуется хранить массив из <math>n</math> элементов.

'''Выходные данные:''' Метки класса (номер кластера) для каждого элемента.

'''Объем выходных данных:''' Для каждого входного элемента достаточно вернуть соответствующую ему метку (число), поэтому минимальный размер выхода: массив из <math>n</math> чисел.

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

Алгоритм является устойчивым.

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

:<math>\frac{O(n^2 + n m_m m_a + n^2 \log{} n)}{n}</math>.

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

:<math>\frac{O(n^2 + n m_m m_a + n^2 \log{} n)}{O(n * (m_a + log(n)))}</math>.

К свойствам алгоритма можно отнести то, что сложность в среднем зависит от данных. Если растет среднее ожидаемое количество соседей, то растет и средняя сложность алгоритма. В худшем случае она может достигать <math>O(n^2)</math> для данных с большой кучностью (одна большая плотная куча, где по факту 1 кластер). Но, если же среднее ожидаемое число соседей меньше <math>log(n)</math>, то сложность алгоритма будет <math>O(n *log(n))</math>. В целом можно взять оценку <math>O(n * m_m)</math>, где <math> m_m </math> максимальное количество соседей.

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
=== Масштабируемость алгоритма ===
Как можно видеть из графа, представленного выше, в алгоритме есть 3 основных места для распараллеливания:
1) Составление матрицы связей
2) Построение локальных куч
3) Основной цикл алгоритма

Теоретическая оценка сложности алгоритма распараллеленного на p потоков:
:<math>O(\frac{n}{p}(n + m_m m_a + n\log{} n))</math>.

Соответственно:
1) При одинаковых входных данных, время работы обратно пропорционально количеству потоков.
2) При одинаковом количестве потоков, время зависит от входных данных кубически в худшем случае.

=== Масштабируемость реализации ===
Реализация алгоритма тестировалась на IBM pSeries 690 HPC Regatta.
* Максимальное количество потоков, способных работать в параллельном режиме: 16.
* Процессоры POWER4 1,3 ГГц; 16-процессорная архитектура SMP

Параметры запусков:
1) Запуски осуществлялись на задачах объемом 400, 800, 1600, 2400 точек.
2) Запуски осуществлялись на 1, 2, 4, 8, 16 потоках.
3) Количество кластеров = 2, <math>\theta</math> = 0.3, соседями считались все точки в радиусе 0.3 .

{| class="wikitable"
|-
! Количество потоков / Количество точек
! 400
! 800
! 1200
! 1600
|-
| 1
| 23 с.
| 188 с.
| 631 с.
| 1514 с.
|-
| 2
| 17 с
| 134 с
| 452 с
| 1079 с
|-
| 4
| 10 с
| 79 с
| 268 с
| 631 с
|-
| 8
| 8 с
| 45 с
| 144 с
| 342 с
|-
| 16
| 4 с
| 24 с
| 79 с
| 185 с
|}

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

Наглядно эти данные можно увидеть на следующем изображении.
[[Файл:Rock regatta.png|1200px|center|thumb|рис 2. Масштабируемость реализации]]

Реализация доступна по ссылке на github [https://github.com/refalc/rock_cmc_msu/]

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

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

== Существующие реализации алгоритма ==
feed4weka [https://sourceforge.net/projects/feed4weka/files/] - открытая библиотека, которая содержит различные алгоритмы для работы с данными.

= Литература =
1) ROCK: A Robust Clustering Algorithm for
Categorical Attributes[https://www.cis.upenn.edu/~sudipto/mypapers/categorical.pdf]

2) Data Mining Algorithms In R/Clustering/RockCluste [https://en.wikibooks.org/wiki/Data_Mining_Algorithms_In_R/Clustering/RockCluster]

[[en:Description of algorithm properties and structure]]

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

2016-11-22T11:48:10Z

Teplov: /* Замечания */

== Статья [[Самоорганизующиеся карты Кохонена]] ==

=== Замечания ===
* Формулы нужно оформить в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:37, 23 октября 2016 (MSK)
* Графы рис 4,5 имеют уж очень округлые дуги. Сильно это восприятию не мешает, для построенного размера, но лучше дуги сделать значительно более прямыми [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:39, 23 октября 2016 (MSK)
* В п. 1.7 не указаны параметры для которых построен граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:39, 23 октября 2016 (MSK)
* В п 1.10 нет оценки вычислительной мощности [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:39, 23 октября 2016 (MSK)
* Отсутствует краткая сводка свойств алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:11, 23 октября 2016 (MSK)
* Отсутствуют данные по вычислительным экспериментам. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:48, 22 ноября 2016 (MSK)

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

2016-11-22T11:46:55Z

Teplov: /* Замечания */

== Статья [[Самоорганизующаяся карта Кохонена (алгоритм кластеризации)]] ==

=== Структура статьи ===
* Пункт Литература должен быть 3 а не 2.8 [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:24, 23 октября 2016 (MSK)

=== Замечания ===
* Формулы нужно выделить в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:24, 23 октября 2016 (MSK)
* Код нужно выделить в отдельные блоки для лучшей читаемости [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:24, 23 октября 2016 (MSK)
* Графы рис 3а и особенно 3б имеют запутанную структуру. Можно ее представить значительно более просто и понятно [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:24, 23 октября 2016 (MSK)
** Необходимо улучшить читаемость всего графа (особенно 3a). Примеров построения информационного графа с меньшим числом пересечений дуг, способов организации и визуализации блоков можно найти на АлгоВики достаточно много. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:46, 22 ноября 2016 (MSK)
* В п. 1.7 не указаны параметры алгоритма, для которых построен граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:24, 23 октября 2016 (MSK)

* остутствуют данные по вычислительному эксперименту. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:46, 22 ноября 2016 (MSK)

Самоорганизующаяся карта Кохонена (алгоритм кластеризации)

2016-11-22T11:43:59Z

Teplov:

Авторы проекта: [[Участник:Eugene|Быковец Евгений Владимирович (620 группа)]] и [[Участник:Crowslord|Ворона Игорь Игоревич (620 группа)]]
Быковец Е.В.: 1.1,1.2,1.3,1.4,1.5,2.7
Ворона И.И.: 1.6,1.7,1.8,1.9,1.10,2.8

{{algorithm
| name = Алгоритм кластеризации, основанный на самоорганизующихся сетях Кохонена
| serial_complexity = <math>O(TMn) + O(M^2)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>O(nN)</math>
| output_data = <math>O(nM)</math>
}}

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

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

Cамоорганизующаяся карта Кохонена (Self-Organizing Map, SOM) представляет из себя вычислительный метод, предназначенный для задач, в первую очередь, кластеризации и визуализации, а также анализа данных из пространств высокой размерности (иначе, многомерных данных), полученных экспериментально. Методы был предложен Туево Кохоненом (1982). Прародителями модели самоорганизующейся сети Кохонена были ранние нейросетевые модели (в частности, модель ассоциативной памяти и модель адаптивного обучения).

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

Архитектура самоорганизующейся карты Кохонена следующая: имеется два слоя - входной слой (распределительный) нейроноы и выходной слой (слой Кохонена) нейронов, при этом нейроны второго слоя расположены в виде двумерной решетки (обычно сетка либо квадратная, либо шестиугольная, об этом далее), так, что каждый нейрон из первого слоя соединен с каждым нейроном второго слоя (см. рис. 1) [[Файл:General Kohonen.png|thumb|200px|right|Рис. 1. Общая структура карты Кохонена]]Количество нейронов входного слоя равно размерности исходного пространства. Чаще нейроны слоя Кохонена принято называть кластерными элементами. Более точно, их количество определяет количество кластеров, на которые карта может разбить данные, которые поданы на распределительный слой. Чем больше кластерных элементов, тем более гранулярная кластеризация. Как уже было сказано, топология слоя Кохонена может быть представлена либо виде четырехугольной сетки, либо в виде шестиугольной сетки. Второй вариант более привлекателен в силу того, что расстояния для каждого нерона до каждого соседнего с ним нейрона одинаковые. Более наглядно это представлено на рисунках (cм. рис. 2а, рис. 2б) [[Файл:quadr.jpg|thumb|200px|right|Рис. 2а.Четырехугольная решетка слоя Кохонена]] [[Файл:hex.png|thumb|200px|right|Рис. 2б.Шестиугольная решетка слоя Кохонена]]

Каждый нейрон выходного слоя определяется вектором весов (размерность вектора - есть разность входного пространства) и упорядоченной парой : <math>(x,y)</math>, определяющую позицию нейрона на карте Кохонена.

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

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

== Математическое описание алгоритма ==
=== Используемые обозначения ===

<math>t</math> - номер итерации,

<math>n</math> - размерность исходного пространства,

<math> \chi \subset R^n</math> - обучающая выборка,

<math> \Phi \subset R^n </math> - тестовая выборка,

<math> N = |\chi|</math> - размер обучающей выборки,

<math> K = |\Phi|</math> - размер тестовой выборки,

<math> a </math> - высота слоя Кохонена,

<math> b </math> - ширина слоя Кохонена,

<math> M = a \times b </math> - общее количество нейронов в слое Кохонена,

<math> ne_j, j=1,...M </math> - нейрон с индексом <math>j</math>,

<math>\vec{x}^{(i)}(t) = (x_1^{(i)}(t),...,x_n^{(i)}(t)), i=1,..,N</math> - <math>i</math>-й вектор, подлежайщий кластеризации,

<math>\vec{w}^{(j)}(t) = (w_1^{(j)}(t),...,w_n^{(j)}(t)), j = 1,..,M</math> - вектор весовых коэффициентов для <math>j</math>-го нейрона,

<math> r_k</math> - положение <math>k</math>-го нейрона в топологии карты, то есть <math>(i_k,j_k)</math>,

<math> h_{ij}(t)</math> - функция соседства между нейронами с индексами <math>i</math> и <math>j</math> на итерации t,

<math> h(d,t) </math> - функция от расстояния между нейронами,

<math> \alpha(t)</math> - скорость обучения сети,

<math> \sigma(t) </math> - функция, уменьшающая количество соседей с при увеличении итерации (монотонно убывающий),

<math> T </math> - максимальное число итераций алгоритма обучения - может быть задано фиксировано, либо же равно мощности обучающей выборки, то есть <math> N </math>.

=== Алгоритм обучения ===

Шаг №0. Определить значение параметров алгоритма: используемые метрики, функции <math>\alpha(t) </math>, <math>\sigma(t) </math>, <math>t:= 0 </math>

Шаг №1. Инициализировать векторы начальных весов нейронов <math> \vec{w}^{(j)}(0) \forall j=1,..,M</math>. Подробнее о стратегии начальной инициализации далее.

шаг №2. Если есть еще элементы в обучающей выборке, вытащить случайным образом (например, индекс <math>i</math> - может быть реализацией случайной величины из равномерного дискретного распределения на <math> [0,N] </math>) входной вектор <math>\vec{x}^{(i)}(t), N:=N-1, \chi = \chi \setminus \vec{x}^{(i)}(t)</math>, в противном случае алгоритм завершает свою работу

шаг №3. Для <math>\vec{x}^{(i)}(t)</math> и <math> \vec{w}^{(j)}(t) \forall j=1,..,M</math> найти <math> = \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t)) = || \vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)||^2 </math>.

шаг №4. Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, M\}} \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t))</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}(t)</math> по рассматриваемой метрике <math> || \circ || </math>.

шаг №5. Для всех нейронов <math> ne_{j} </math> выполнить пересчет весовых векторов:
<math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>.

шаг №6. <math>t := t+1 </math>

шаг №7. Перейти к шагу 2.

=== Настройка алгоритма ===

В этом разделе опишем более подробно настраиваемые аспекты алгоритма.

==== Выбор начального приближения для <math>\vec{w}^{j}(0) \forall j=1,\dots,M</math> ====

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

Во-вторых, инициализацию весов можно проводить какими-то случайными значениями. Например можно взять нескорое распределение, пусть равномерное или нормальное, и для каждой сгенерировать псевдослучайное число из выбранного распределения, то есть <math> w_i^{(j)} \sim \mathbf P </math>, где <math> \mathbf P </math> - это заданное распределение. Плюсом данного подхода является простота однако, "настройка" в данном случае может быть долгой.

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

==== Выбор скорости обучения сети ====

Функцию скорости обучения сети <math>\alpha(t)</math> можно выбрать, например, следующим образом:

Самый простой способ: <math>\alpha(t) := \frac{A}{B+t}</math>, где <math>A = const, B = const </math>

Экспоненциальная скорость обучения: <math>\alpha(t) := \alpha_0 e^{ -\frac{t}{\lambda}}, \lambda \in (0, 1), \lambda = const, \alpha_0 = const</math>

Показательная скорость обучения: <math>\alpha(t) := \lambda^{\frac{t}{T}}, \lambda \in (0, 1), \lambda = const</math>

==== Выбор функции соседства между нейронами ====

Обычно полагают <math> h_{cj}(t) := \alpha(t) h(d,t) </math>, где <math> d = || ne_c - ne_j ||, c </math> -индекс нейрона победителя, при этом:

<math> h(d,t) = \begin{cases}const, d\leq \sigma(t) \\0, d > \sigma(t) \end{cases}</math>

<math> h(d,t) = e ^{-\frac{d^2}{2(\sigma(t)^2)}}</math>, где <math>\sigma(t)</math> - это некоторый сомножитель, уменьшающий количество соседей, которые будут подвержены корректировке весов с увеличением итераций, эта функция монотонно убывает.

Функция <math> \sigma(t) </math> также является параметром алгоритма. Возможная функциональная зависимость для нее:
<math>\sigma(t) = \frac{\sigma_0}{1 + \frac{t}{T}}</math>.

Стоит отметить, что имеется много других эвристических мер сходств которые присваивают ненулевые веса внутри некоторого радиуса, это позволяет производить вычисления не для всех соседей.

=== Алгоритм работы карты ===

шаг 0. Пока есть вектора в тестовой выборке извлечь (последовательно), <math>\vec{x}^{(i)}, K:=K-1, \Phi = \Phi \setminus \vec{x}^{(i)}</math>, в противном случае алгоритм завершает свою работу.

шаг 1. Для <math>\vec{x}^{(i)}</math> и <math> \vec{w}^{(j)} \forall j=1,..,M</math> найти <math> \rho(\vec{x}^{(i)}, \vec{w}^{(j)}) = || \vec{x}^{(i)} - \vec{w}^{(j)}||^2 </math>.

шаг 2. Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}, \vec{w}^{(j)})</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}</math> по рассматриваемой метрике <math> || \circ || </math> и относим <math>\vec{x}^{(i)} </math> к кластеру, соответствующему нейрону <math>ne_c</math>.

шаг 3. Переход к шагу 0.

== Вычислительное ядро алгоритма ==

Вычислительное ядро алгоритма обучения составляет (соответсвенно, пункты 3,4,5 алгоритма обучения):

* подсчет расстояний между входным вектором и всеми нейронами:

Для <math>\vec{x}^{(i)}(t)</math> и <math> \vec{w}^{(j)}(t) \forall j=1,..,M</math> найти <math> = \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t)) = || \vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)||^2 </math>.

* Поиск минимума между всеми найденными расстояниями для нахождения нейрона-победителя:

Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}(t), \vec{w}^{(j)}(t))</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}(t)</math> по рассматриваемой метрике <math> || \circ || </math>.

* Корректировка весовых векторов: сюда же входит поиск расстояний между всеми нейронами в рамках заданной топологии, а также вычисление функции соседства:

Для всех нейронов <math> ne_{j} </math> выполнить пересчет весовых векторов:
<math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>.

Вычислительное ядро алгоритма работы составляет (соответсвенно, пункты 1, 2 алгоритма работы):

* подсчет расстояний между входным вектором и всеми нейронами:

Для <math>\vec{x}^{(i)}</math> и <math> \vec{w}^{(j)} \forall j=1,..,M</math> найти <math> \rho(\vec{x}^{(i)}, \vec{w}^{(j)}) = || \vec{x}^{(i)} - \vec{w}^{(j)}||^2 </math>.

* Поиск минимума между всеми найденными расстояниями для нахождения нейрона-победителя:

Находим нейрон-победитель <math>ne_c</math>, <math> c = \arg \min_{\forall j \in \{1, \dots, L\}} \rho(\vec{x}^{(i)}, \vec{w}^{(j)})</math>, который лежит ближе к текущему объекту <math>\vec{x}^{(i)}</math> по рассматриваемой метрике <math> || \circ || </math> и относим <math>\vec{x}^{(i)} </math> к кластеру, соответствующему нейрону <math>ne_c</math>.

== Макроструктура алгоритма ==
В алгоритме обучения можно выделить 4 макрофазы:

* Начальная инициализация всех весов: построение матрицы <math> \mathbf{ W(0)} \in \mathbf {R^{N \times M}} </math>, столбцами которой являются весовые вектора всех нейронов.

* Выполнение следующих фаз <math> \mathbf T </math> раз:
** Вычисление вектора расстояний <math> \mathbf D \in \mathbf {R^M} </math>, в котором хранятся вектора расстояний от вектора <math> \mathbf X </math> до векторов матрицы <math> \mathbf {W(t)} </math>.
** Нахождение индекса минимума в векторе <math> \mathbf D </math> - индекса нейрона победителя;
** Корректировка всех весов: получение матрицы <math> \mathbf {W(t+1)} </math>

В алгоритме работы алгоритма можно выделить две макрофазы:

* Выполнение следующих фаз <math> \mathbf K </math> раз:
** Вычисление вектора расстояний <math> \mathbf D \in \mathbf {R^M} </math>, в котором хранятся вектора расстояний от вектора <math> \mathbf X </math> до векторов матрицы <math> \mathbf {W} </math>.
** Нахождение индекса минимума в векторе <math> \mathbf D </math> - индекса нейрона победителя и определение входного вектора в кластер, соответсвующий нейрону-победителю;

Также можно выделить математические операции, используемые в вышеприведенных:
* <math>\vec{x}^{T} \vec{y}</math> - скалярное произведение вектров;
* <math>\vec{x} + \vec{y}</math> - сложение двух векторов;
* <math>\lambda \vec{x}</math> - умножение вектора на скаляр;
* <math>\min_i x_i</math> - поиск минимального элемента в векторе <math>\vec{x}</math>;
* Вычисление функции соседства <math> h_{ci}(t) </math>

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

Схему реализации последовательного алгоритма обучения запишем в виде псевдокода:
<syntaxhighlight lang=oberon2>
SetAlgorithmParameters()
CalculateDistancesBetweenNeuronsInEuclidianPlane()
W = SetNeuronWeightsVector()
FOR t = 1 to T do
x = ChooseInputVector()
D = InitialiseDistancesVector()
FOR n = 1 to M do
d = CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)
PutCalculatedDistanceToDistancesVector(D, d)
END FOR
ne_c = FindNeuronWinner(D)
FOR n = 1 to M do
CorrectNeuronsWeightsVector(W)
END FOR
END FOR
</syntaxhighlight>

Схему реализации последовательного алгоритма работы запишем в виде псевдокода:
<syntaxhighlight lang=oberon2>
FOR t = 1 to T do
x = ChooseInputVector()
D = InitialiseDistancesVector()
FOR n = 1 to K do
d = CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)
PutCalculatedDistanceToDistancesVector(D, d)
END FOR
ne_c = FindNeuronWinner(D)
DefineInputVectorToCluster()
END FOR
</syntaxhighlight>

Дадим комментарии по некоторым функциям:
<math>SetAlgorithmParameters()</math> - установка параметров алгоритма проводится исследователем для увеличения/уменьшения гранулярности кластеризации;

<math>CalculateDistancesBetweenNeuronsInEuclidianPlane()</math> - вычисление матрицы расстояний между всеми нейронами в Евклидовой плоскости, в соответствии с их расположением в слое Кохонена - эта информация потребуется <math>CorrectNeuronsWeightsVector(W)</math>.

<math>W = SetNeuronWeightsVector()</math> - установка векторов веса нейронов (стратегии инициализации были рассмотрены выше: случайным образом, значениями из обучающей выборки, с помощью значений из пространства векторов, натянутого на главные компоненты);

<math>x = ChooseInputVector()</math> - выбор входного вектора из выборки (стратегия выбора также было рассмотрена выше: индекс вектора в обучающей выборке - реализация случайной величины из заданного распределения вероятностей, например);

<math>D = InitialiseDistancesVector()</math> - заполнение массива растояний нулями;

<math>d= CalculateDistanseBetweenInputVectorAndNeuronWeightsVector(x,n)</math> - вычисление расстояния между входным вектором и вектора веса нейрона по выбранной метрике (например, евклидовом);

<math>PutCalculatedDistanceToDistancesVector(D, d)</math> - добавление вычисленного расстояния между входным вектором и вектором веса текущего нейрона в массив расстояний;

<math>ne_c = FindNeuronWinner(D)</math> - нахождение нерона победителя, индекс которого является индексом минимума в массиве расстояний;

<math>CorrectNeuronsWeightsVector(W)</math> - корректировка весов нейронов по формуле: <math> \vec{w}^{(j)}(t+1) := \vec{w}^{(j)}(t) +\alpha(t)h_{ci}(t)[\vec{x}^{(i)}(t) - \vec{w}^{(j)}(t)]</math>;

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

== Последовательная сложность алгоритма ==
Начнём рассмотрение сложности последовательной реализации алгоритма Кохонена «сверху – вниз» начиная со сложности максимально абстрактного набора функций и потом конкретизируя сложность каждой функции в рамках фундаментальных вычислительных операций (присваивание, суммирование и т.п.). Это позволяет пересчитать сложность алгоритма Кохонена при условии замены функции составляющих его основу и при реализации его на целевую платформу.

'''I АЛГОРИТМ ОБУЧЕНИЯ'''

1) Уровень набора функций

:<math>Complexity(SOMLearning) = </math>

:<math>Complexity(SetAlgorithmParameters) +</math>

:<math>Complexity(CalculateDistancesBetweenNeuronsInEuclidianPlane) +</math>

:<math>Complexity(SetNeuronWeightsVector) +</math>

:<math>T \cdot Complexity(ChooseInputVector) +</math>

:<math>T \cdot Complexity(InitialiseDistancesVector) +</math>

:<math>T \cdot M \cdot Complexity(CalculateDistanseBetweenInputVectorAndNeuronWeightsVector) +</math>

:<math>T \cdot M \cdot Complexity(PutCalculatedDistanceToDistancesVector) +</math>

:<math>T \cdot Complexity(FindNeuronWinner) +</math>

:<math>T \cdot M \cdot Complexity(CorrectNeuronsWeightsVector)</math>

2) Уровень реализации функций в рамках фундаментальных операций

Будем считать, что следующие операции выполняются за константное время (<math>O(1)</math>):

:<math>mov</math> - присваивание

:<math>sqrt</math> - взятие квадратного корня из числа

:<math>rand</math> – генерация случайного числа

:<math>add</math> - сложение

:<math>sub</math> - вычитание

:<math>mul</math> - умножение

:<math>comp</math> - сравнение

:<math>exp</math> - экспоненцирование

:<math>div</math> - деление

Тогда:
:Так как параметров всегда конечное число и мы делаем допущение, что это число меньше M и T:

:<math>Complexity(SetAlgorithmParameters) = O(Complexity(mov)) = O(1)</math>

:<math>Complexity(CalculateDistancesBetweenNeuronsInEuclidianPlane) = </math>
:<math>O(M \cdot (M-1) \cdot (2 \cdot Complexity(sub) + 2 \cdot Complexity(mul) +</math>
:<math> Complexity(add) + Complexity(sqrt))) = O(M^2)</math>

:<math>Complexity(SetNeuronWeightsVector) = O(Mn \cdot Complexity(mov)) \vee O(Mn \cdot Complexity(rand))) = O(Mn)</math>

:<math>Complexity(ChooseInputVector) = O(n \cdot Complexity(mov))= O(n)</math>

:<math>Complexity(InitialiseDistancesVector) = O(M \cdot n \cdot Complexity(mov)) = O(M \cdot n)</math>

:<math>Complexity(CalculatedDistanseBetweenInputVectorAndNeuronWeightsVector) = O(n \cdot Complexity(sub)) +</math>
:<math>O(n \cdot Complexity(mul)) + O((n - 1) \cdot Complexity(add)) = O(n)</math>

:<math>Complexity(PutCalculatedDistanceToDistancesVector) = O(n \cdot Complexity(mov)) = O(n)</math>

:<math>Complexity(FindNeuronWinner) = O(M \cdot n \cdot Complexity(comp)) = O(Mn)</math>

:<math>Complexity(CorrectNeuronsWeightsVector) = O(nComplexity(add)) + O(nComplexity(mul)) + </math>
:<math>O(Complexity(NeighborhoodFunction)) = O(n) + O(Complexity(NeighborhoodFunction)) = O(n) +</math>
:<math> O(Complexity(exp) + Complexity(div)) = O(n)</math>

3) Конечная сложность

:<math>Complexity(SOMLearning) = O(1) + O(M^2) + O(Mn) + O(Tn) + O(TMn) + O(TMn) + O(TMn) + O(TMn) + O(TMn) =</math>

:<math> O(TMn) + O(M^2)</math>

'''II АЛГОРИТМ РАБОТЫ'''

1) Уровень набора функций

:<math>Complexity(SOMWorking) = </math>

:<math>T \cdot Complexity(ChooseInputVector) +</math>

:<math>T \cdot Complexity(InitialiseDistancesVector) +</math>

:<math>T \cdot K \cdot Complexity(CalculateDistanseBetweenInputVectorAndNeuronWeightsVector) +</math>

:<math>T \cdot K \cdot Complexity(PutCalculatedDistanceToDistancesVector) +</math>

:<math>T \cdot Complexity(FindNeuronWinner) +</math>

:<math>T \cdot Complexity(DefineInputVectorToCluster)</math>

2) Уровень реализации функций в рамках фундаментальных операций

Эквивалентно п.2 в Алгоритме обучения (но в качестве M у нас K).

:<math>Complexity(DefineInputVectorToCluster) = O(1)</math>

3) Конечная сложность

:<math>Complexity(SOMWorking) = O(Tn) + O(TKn) + O(TKn) + O(TKn) + O(TKn) + O(T) = O(TKn)</math>

== Информационный граф ==
[[Файл:InfGraphSOM.png|500px|thumb|right|Рис. 3а.Информационный граф алгоритма обучения]]

В качестве операторных узлов информационного графа были выбраны:

• '''||a – b||''' - взятие евклидовой метрики от двух операндов

• '''FindMinimum''' – нахождение минимума из входящих значений

• '''UpdateWeights''' – обновление весов (для каждого входящего вектора отдельный узел)

• '''DefineCluster''' – определение кластера на основе полученного значения от нахождения минимума

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

Входные параметры алгоритма, для которого был построен информационный граф:

<math> N = 2</math> - размер обучающей выборки,

<math> K = 2</math> - размер тестовой выборки,

<math> a = 1</math> - высота слоя Кохонена,

<math> b = 2</math> - ширина слоя Кохонена,

Остальные параметры могут быть любыми, так как не оказывают влияние на построенный информационный граф.
[[Файл:InfGraphSOM2.png|500px|thumb|center|Рис. 3б.Информационный граф алгоритма работы]]

== Ресурс параллелизма алгоритма ==
Для того чтобы оценить насколько эффективно Алгоритм Кохонена параллелизуется, рассмотрим его структуру в виде последовательности этапов исполнения. Вначале рассмотрим алгоритм обучения. У нас есть 4 фундаментальных этапа:

[[Файл:SOMParallel.png|500px|thumb|right|Рис. 4.Пример параллельного алгоритма SOM при threadNumber = 2]]
1) '''Инициализация'''. На этом этапе мы определяем параметры алгоритма, рассчитываем расстояния между нейронами и определяем начальные веса нейронов. Здесь имеет смысл распараллелить подсчет метрики между нейронами. Таким образом асимптотическая сложность упадет с <math>O(M^2)</math> до <math>O(\frac{M^2}{threadNumber})</math>

2) '''Генерация подвыборки'''. Здесь мы определяем в каком порядке будем обрабатывать вектора исходного входного пространства, какой вектор возьмём для следующей итерации. К сожалению, эта стадия не поддается распараллеливанию, так как каждая итерация алгоритма зависит от предыдущей;

3) '''Поиск максимального подобия'''. Находим наиболее подходящий (победивший) нейрон, используя критерий минимума Евклидова расстояния. Этот этап распараллеливается следующим образом. Вначале мы рассчитываем метрику между вектором весов каждого нейрона и входящим вектором исходного пространства, для этого мы разбиваем количество нейронов <math>M</math> на <math>threadNumber</math> потоков и подсчитываем метрику в каждой группе нейронов на поток параллельно. Затем мы пользуемся фактом, что минимум – дистрибутивная функция (см. Рис. 4)

:<math>min([a, b, c, d]) = min(min([a, b]), min([b, c]))</math>

и рассчитываем её за <math>\log_{2} (threadNumber)</math> операций сравнения, что значительно меньше <math>M</math> в исходном варианте;

4) Коррекция. Корректируем векторы синаптических всех нейронов. Также очевидным образом распараллеливается на <math>threadNumber</math> потоков, в каждым из которых последовательно для каждого нейрона в группе внутри потока обновляются веса.

Итак, общая сложность параллельной версии алгоритма обучения

:<math>Complexity(SOMParallelLearning) = O(\frac{M^2}{threadNumber}) + </math>

:<math>O(\frac{TMn}{threadNumber} + \log_{2} (threadNumber)) + O(\frac{TMn}{threadNumber})</math>

что меньше последовательной (при <math>threadNumber \approx M</math>)

:<math>Complexity(SOMLearning) = O(M^2) + O(TMn) + O(TMn)</math>.

Алгоритм работы карты эквивалентен первым 3 уровням алгоритма обучения только с другими константами
(нужно заменить <math>M</math> на <math>K</math>, предварительно убрав слагаемое <math>O(M^2)</math>,
так как во время работы рассчитывать расстояние между нейронами не нужно).

'''Вывод''': Проведенный обзор показал, что только этап этап генерации подвыборки не поддается распараллеливанию. Это типичная проблема большинства алгоритмов машинного обучения, так как они итеративны (последовательно обучается по всей выборке). Однако в рамках остальных этапов алгоритм легко разбивается на потоки, что в теории улучшает производительность.

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

<math>n</math> - размерность исходного пространства,

<math> \chi \subset R^n</math> - обучающая выборка,

<math> \Phi \subset R^n </math> - тестовая выборка,

<math> N = |\chi|</math> - размер обучающей выборки,

<math> K = |\Phi|</math> - размер тестовой выборки,

<math> a </math> - высота слоя Кохонена,

<math> b </math> - ширина слоя Кохонена,

<math> T </math> - максимальное число итераций алгоритма обучения - может быть задано фиксировано, либо же равно мощности обучающей выборки, то есть <math> N </math>,

<math> h_{ij}(t)</math> - функция соседства между нейронами с индексами <math>i</math> и <math>j</math> на итерации t,

<math> h(d,t) </math> - функция от расстояния между нейронами,

<math> \alpha(t)</math> - скорость обучения сети,

<math> \sigma(t) </math> - функция, уменьшающая количество соседей с при увеличении итерации (монотонно убывающий).

Вычислительная сложность хранения входных данных для алгоритма обучения равна <math>O(n \times N)</math>
(установка функций и прочих параметров выполняется за константное время).

Вычислительная сложность хранения входных данных для алгоритма работы равна <math>O(n \times K)</math>.

'''Выходные данные алгоритма обучения:'''

<math>\vec{w}^{(j)}(t) = (w_1^{(j)}(t),...,w_n^{(j)}(t)), j = 1,..,M</math> - вектор весовых коэффициентов для <math>j</math>-го нейрона,

матрица <math>\mathbf{W}</math>, представляющая веса нейронов <math>\vec{w}^{(j)}(t)</math>
Вычислительная сложность хранения выходных данных равна <math>O(n \times M)</math>.

'''Выходные данные алгоритма работы''':

Вычислительная сложность хранения выходных данных равна <math>O(1)</math>, если алгоритм возвращает индекс кластера или координату нейрона,
иначе если возвращает вектор весов нейрона-победителя, то <math>O(n)</math>

== Свойства алгоритма ==
Итак, вычислительная мощность алгоритма кластеризации самоорганизующимися сетями Кохонена равна

:<math>ComputationalPower(SOM) = \frac{TMn + M^2}{Mn + Tn} = \frac{M(Tn + M)}{n(M + T)}</math>

Cоотношение последовательной и параллельной сложности алгоритма описано в п. 1.8

Детерминированность алгоритма зависит от способа генерации выборки из исходного входного пространства, если она
детерминирована, то и алгоритм детерминирован, иначе нет.

Общие свойства алгоритма:
*Аппроксимация входного пространства. Карта признаков, представленная множеством векторов синоптических весов, в выходном пространстве реализует хорошую аппроксимацию входного пространства.
*Топологический порядок. Карта признаков, полученная алгоритмом SOM, является топологически упорядоченной в том смысле, что пространственное положение нейронов в решетке соответствует конкретной области или признаку входного образа.
*Соответствие плотности. Карта признаков отражает вариации в статистиках распределения входного сигнала. Области во входном пространстве, из которого берутся векторы <math>\vec{x}</math> с большей вероятностью, отображаются в гораздо большие области выходного пространства и, таким образом, с большим разрешением, чем области в исходном пространстве, из которых берутся векторы <math>\vec{x}</math> с меньшей вероятностью.
*Выбор признаков. Для данных из входного пространства с нелинейным распределением самоорганизующаяся карта для аппроксимации исследуемого распределения способна извлечь набор наилучших признаков.

Преимущества алгоритма:

*Является устойчивым, в том числе и к зашумленным данным;
*Реализует быстрое и неуправляемое обучение (процесс самоорганизуюется);
*Может визуализировать многомерные входные данные (упрощения многомерных входных данных с помощью визуализации);
*Может аппроксимировать любую непрерывную функцию, что позволяет исследователю не принимать заранее какие-либо гипотезы относительно модели.

Недостатки алгоритма:

*Работает только с вещественными числовыми векторами;
*Может быть использован для кластерного анализа только в том случае, если заранее известно число кластеров;
*Наличие искажений. Близкие объекты исходного пространства могут переходить в далёкие точки на карте;
*Окончательный результат работы нейронных сетей сильно зависит от начальных установок сети (начальное распределение весов, свойства потенциальной функции).

= Программная реализация алгоритма =

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

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

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

== Масштабируемость алгоритма и его реализации ==

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

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

== Существующие реализации алгоритма ==

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

На данный момент удалось найти следующие последовательные реализации:

* [http://knnl.sourceforge.net/ KNNL]:Реализация на C++
* [https://pypi.python.org/pypi/kohonen kohonen] Реалиазция на Python
* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Реалиазция на R
* [http://jknnl.sourceforge.net/ JKNNL]: Реалиазция на Java.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реалиазция на Matlab.

Также есть параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Реализация на Python, R, Julia, и Matlab, поддерживаются OpenMP, MPI и CUDA.

= Литература =
* T. Kohonen, Self-Organizing Maps (Third Extended Edition), New York, 2001, 501 pages. ISBN 3-540-67921-9
* Нейский И.М. Классификация и сравнение методов кластеризации [[http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf]]
* Хайкин С. Нейронные сети: полный курс, 2-е изд.: Пер. с англ. - М.:ООО "И. Д. Вильямс", 2016. - 1104с. ISBN 978-5-8459-2069-0 (рус.)
* К. В. Воронцов Лекции по искусственным нейронным сетям 21 декабря 2007 г.

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

2016-11-22T11:42:20Z

Teplov: /* Замечания */

== Статья [[Кластеризация сетями Кохонена]] ==

=== Замечания ===
* Формулы в статье лучше выделить в отдельные блоки, примерно так, как это сделано с кодом [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:01, 23 октября 2016 (MSK)
* В п. 1.2 подпункты лучше внести в общую нумерованную иерархию. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:01, 23 октября 2016 (MSK)
* В п. 1.9 должны быть оценки объемов входных и выходных данных [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:07, 23 октября 2016 (MSK)
* Необходимо указать вклад каждого автора [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:38, 23 октября 2016 (MSK)
* Код необходимо вносить в соответствующие теги source ... [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:37, 22 ноября 2016 (MSK)
* Необходимо описание использованной для проведения экспериментов аппаратной платформы. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:42, 22 ноября 2016 (MSK)

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-22T11:38:27Z

Teplov:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

=== Последовательная сложность алгоритма ===

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

Опишем информационный граф алгоритма.

'''Первый этап''' состоит из <math>n</math> параллельных операций вычисления евклидового расстояния до случайно выбранного входного вектора.

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

Для алгоритма кластеризации сетями Кохонена средних имеет место массовый параллелизм: в основе каждого из основных этапов алгоритма (поиска евклидовых расстояний для определения нейрона-победителя и обновления весов) лежат информационно независимые действия.
Учитывая данный факт можно оценить параллельную сложность алгоритма в предположении доступности неограниченного числа необходимых процессоров.

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

Устойчивость к зашумленным данным, быстрое и неуправляемое обучение, возможность упрощения многомерных входных данных с помощью визуализации.
Главное преимущество самоорганизующихся карт Кохонена является их способность "проецирования" многомерных пространств на двумерное. Важной особенностью карт Кохонена является то, что объекты с похожими характеристиками (по всем компонентам) располагаются рядом, образуя кластеры.

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

==== Масштабируемость реализации алгоритма ====

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

Была использована следующая реализация алгоритма.

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **sample;
double **W;
int inputSize=3;
int numNeurons = 10;
int iterNum = 2000;
double learning_rate = 1;
double radius = 0.2;
double eucledeDist(double vect1[],double vect2[]) {
double sum = 0;
for (int i = 0; i <inputSize; ++i){
sum += (vect1[i]-vect2[i])*(vect1[i]-vect2[i]);
}
return sqrt(sum);
}

double ** getRandomArray(int rows, int cols, int randomize, int init=0){
double ** matr = new double* [rows];
for (int i = 0; i < rows; ++i){
matr[i] = new double[cols]();
}
if (randomize==1){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matr[i][j] = (10*rand()-8*rand())/32767.0;
if (init){matr[i][j] /= 40;}
}
}
}
return matr;
}

int main()
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

//for each epoch
for (int iter = 0; iter < iterNum; ++iter){

//choose winner
int winner_num = 0;
double winnerDist = eucledeDist(sample[iter],W[0]);
double dist = 0;
for (int i = 1; i < numNeurons; ++i){
dist = eucledeDist(sample[iter],W[i]);
if ( dist < winnerDist) {
winner_num=i;
winnerDist=dist;
};
}

// correct weights
double *winner = W[winner_num];
for (int i = 0; i < numNeurons; ++i){
dist = eucledeDist(winner,W[i]);
if (dist<radius && i!=winner_num) {
for (int j = 0; j < inputSize; ++j){
W[i][j] += learning_rate/sqrt(iter+1) * (winner[j]-W[i][j]);
}

}
}
}
return 0;
}

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

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

2016-11-22T11:37:57Z

Teplov: /* Статья Кластеризация сетями Кохонена */

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

2016-11-22T11:37:37Z

Teplov: /* Замечания */

Обсуждение участника:Логвиненко Александра

2016-11-22T11:34:49Z

Teplov: /* Не полная структура статьи */

== Статья [[Алгоритм кластеризации, основанный на сетях Кохоннена]] ==

=== Не полная структура статьи ===
* В статье отсутствуют пункты с 2.2 по 2.7 [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
** Исправлено [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 20:57, 28 октября 2016 (MSK)
* Пункт 2.1 имеет неправильное название и должен быть пунктом 2.7 [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
** Исправлено [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 20:57, 28 октября 2016 (MSK)
* Отсутсвует кратакая сводка свойств алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 02:10, 23 октября 2016 (MSK)
* Отсутствуют данные по вычислительным экспериментам [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 14:34, 22 ноября 2016 (MSK)

=== Замечания по оформлению ===
* В п. 1.3 формулы оформлены по разному. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
** Исправлено [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 21:02, 28 октября 2016 (MSK)
* В п. 1.7 отсутствуют данные о том, для каких параметров построен граф [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
* В п. 1.8 должна быть оценка параллельной сложности алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
* В п. 1.10 должна присутствовать вычислительная мощность алгоритма [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:37, 22 октября 2016 (MSK)
* Часть рисунков не подписана и отсутствует их нумерация. [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 17:42, 22 октября 2016 (MSK)
** исправлено [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 21:02, 28 октября 2016 (MSK)
* Необходимо указать вклад каждого автора [[Участник:Teplov|Teplov]] ([[Обсуждение участника:Teplov|обсуждение]]) 00:41, 23 октября 2016 (MSK)

Алгоритм Форда-Фалкерсона

2016-11-18T21:52:15Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Форда-Фалкерсона'''<ref>Ford, L R, Jr., and D R Fulkerson. “Maximal Flow Through a Network.” Canadian Journal of Mathematics 8 (1956): 399–404. doi:10.4153/CJM-1956-045-5.</ref><ref>Ford, L R, Jr., and D R Fulkerson. “A Simple Algorithm for Finding Maximal Network Flows and an Application to the Hitchcock Problem.” Canadian Journal of Mathematics 9 (1957): 210–18.</ref> (с последующими усовершенствованиями '''Эдмондса-Карпа'''<ref name=EdmondsKarp>Edmonds, Jack, and Richard M Karp. “Theoretical Improvements in Algorithmic Efficiency for Network Flow Problems.” Journal of the ACM 19, no. 2 (April 1972): 248–64. doi:10.1145/321694.321699.</ref> и '''Е. А. Диница'''<ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57.</ref>) предназначен для решения задачи о [[Поиск максимального потока в транспортной сети|максимальном потоке в транспортной сети]]. Время работы алгоритма <math>O(n^2m)</math> (для алгоритма Диница). В случае целых пропускных способностей, не превосходящих <math>K</math>, сложность <math>O(Km)</math> (для алгоритма Эдмондса–Карпа).

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

* В исходном алгоритме Форда–Фалкерсона способ выбора дополняющего пути не уточнялся.
* В алгоритме Эдмондса-Карпа выбирается кратчайший дополняющий путь, для чего используется [[Поиск в ширину (BFS)|поиск в ширину]] на каждой итерации;
* В алгоритме Диница для выбора кратчайшего пути поддерживается «расслоение» графа, так что поиск в ширину выполняется значительно реже.

=== Математическое описание алгоритма ===

Математическая постановка задачи приведена в статье «[[Поиск максимального потока в транспортной сети|Поиск максимального потока в транспортной сети]]», там же введены используемые обозначения.

Пусть задан некоторый допустимый поток <math>f</math>. ''Дополняющим путём'' называется последовательность рёбер <math>e_0 = (s, v_1), e_1 = (v_1, v_2), \ldots, e_k = (v_k, t)</math>, каждое из которых обладает положительной ''остаточной пропускной способностью'' <math>c_f(e_i) = c(e_i) - f(e_i) > 0</math>.

Поток останется допустимым, если увеличить его вдоль дополняющего пути на число <math>\delta = \min \{ c(e_i) - f(e_i) \} > 0</math>, при этом величина потока возрастёт на то же число <math>\delta</math>. Для сохранения антисимметричности увеличение потока производится присваиваниями

:<math>
f(e_i) \leftarrow f(e_i) + \delta, \quad f(e_i^R) \leftarrow f(e_i^R) - \delta, \quad i = \overline{0, k}.
</math>

Если дополняющего пути не существует, то поток <math>f</math> является максимальным.

=== Вычислительное ядро алгоритма ===

Вычислительными ядрами, на которые приходится наибольший объём вычислений, являются:
* [[Поиск в ширину (BFS)|поиск в ширину]];
* увеличение потока вдоль дополняющего пути.

=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
=== Последовательная сложность алгоритма ===

В статье Эдмондса–Карпа<ref name=EdmondsKarp /> (теорема 1) доказано, что количество последовательно построенных кратчайших дополнительных путей не превосходит <math>m(n + 1)/2 = O(mn)</math>. Основными операциями алгоритма являются поиск в ширину сложностью <math>O(m)</math> и обновление потока вдоль дополняющего пути сложностью <math>O(n)</math>.

В '''алгоритме Эдмондса–Карпа''' выполняются следующие операции:
* поиск в ширину и определение кратчайшего пути на каждой итерации, сложность <math>O(m + n)</math>, общая сложность <math>O(m^2n)</math>;
* обновление потока вдоль дополняющего пути, сложность <math>O(n)</math>, общая сложность <math>O(n^2 m)</math>.
Таким образом, общая сложность составляет <math>O(m^2n)</math>.

В '''алгоритме Диница''' выполняются следующие операции:
* поиск кратчайшего пути и обновление потока вдоль дополняющего пути на каждой итерации, сложность <math>O(n)</math>, общая сложность <math>O(mn^2)</math>;
* обновление расслоения на каждой итерации, сложность <math>O(1)</math>, общая сложность <math>O(mn)</math>;
* поиск в ширину для построения нового расслоения, сложность <math>O(m)</math>, число построений не более <math>n</math>, общая сложность <math>O(mn)</math>.
Таким образом, общая сложность составляет <math>O(mn^2)</math>.

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

Далее представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. Информационный граф алгоритма — ориентированный граф, состоящий из вершин, соответствующих операциям алгоритма, и направленных дуг, соответствующих передаче данных (результаты одних операций передаются в качестве аргументов другим операциям) между ними.

[[file:Max flow.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Форда-Фалкерсона]]

=== Ресурс параллелизма алгоритма ===
Основной объём вычислений в алгоритме Форда-Фалкерсона приходится на поиск путей от источника к стоку. С этой целью может применяться [[Поиск в ширину (BFS)|поиск в ширину]], который хорошо распараллеливается. Наилучших результатов можно достичь, если распределить вершины между узлами по слоям примерно одинаковой толщины, так что в каждом слое вершины были бы примерно на одинаковом удалении от источника (такое расслоение также можно найти поиском в ширину).

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

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

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/edmonds_karp_max_flow.html edmonds_karp_max_flow]</code>): алгоритм Эдмондса–Карпа, сложность <math>O(nm^2)</math> для действительных весов и <math>O(Kmn)</math> для целых, не превосходящих <math>K</math>.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.flow.edmonds_karp.html edmonds_karp]</code>): алгоритм Эдмондса–Карпа, сложность <math>O(nm^2)</math>.
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/EdmondsKarpMaximumFlow.html EdmondsKarpMaximumFlow]</code>), алгоритм Эдмондса–Карпа, сложность <math>O(nm^2)</math>.

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

<references />

[[Категория:Начатые статьи]]

Алгоритм Пурдома

2016-11-18T21:02:51Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(m + \mu n)</math>, где <math>\mu \le m</math> – число [[Связность в графах|компонент сильной связности]] этого графа.

=== Математическое описание алгоритма ===

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

=== Последовательная сложность алгоритма ===

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(m)</math>.

На третьем этапе основой операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>n</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматов хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu n)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>n</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(m + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(m + \mu n)</math> в противном случае.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
Программа, реализующая поиск транзитного замыкания, состоит CPU части, отвечающей за общую координацию вычислений, использующей вспомогательные классы.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

[[file:Замыкание scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Пурдома масштабируемость различных версий: производительность в зависимости от размера графа.]]

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

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

<references />

[[Категория:Начатые статьи]]

Алгоритм Пурдома

2016-11-18T20:52:43Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(m + \mu n)</math>, где <math>\mu \le m</math> – число [[Связность в графах|компонент сильной связности]] этого графа.

=== Математическое описание алгоритма ===

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

=== Последовательная сложность алгоритма ===

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(m)</math>.

На третьем этапе основой операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>n</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматов хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu n)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>n</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(m + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(m + \mu n)</math> в противном случае.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
Программа, реализующая поиск транзитного замыкания, состоит CPU части, отвечающей за общую координацию вычислений, использующей вспомогательные классы.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

[[file:Замыкание scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Пурдома масштабируемость различных версий: производительность в зависимости от размера графа.]]

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

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

<references />

[[Категория:Начатые статьи]]

Алгоритм Пурдома

2016-11-18T20:51:59Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(m + \mu n)</math>, где <math>\mu \le m</math> – число [[Связность в графах|компонент сильной связности]] этого графа.

=== Математическое описание алгоритма ===

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

=== Последовательная сложность алгоритма ===

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(m)</math>.

На третьем этапе основой операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>n</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматов хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu n)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>n</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(m + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(m + \mu n)</math> в противном случае.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
Программа, реализующая поиск транзитного замыкания, состоит CPU части, отвечающей за общую координацию вычислений, использующей вспомогательные классы.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

[[file:Замыкание scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Пурдома масштабируемость CPU версии: производительность в зависимости от размера графа.]]

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

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

<references />

[[Категория:Начатые статьи]]

Алгоритм Пурдома

2016-11-18T20:45:32Z

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

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(m + \mu n)</math>, где <math>\mu \le m</math> – число [[Связность в графах|компонент сильной связности]] этого графа.

=== Математическое описание алгоритма ===

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

=== Последовательная сложность алгоритма ===

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(m)</math>.

На третьем этапе основой операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>n</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматов хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu n)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>n</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(m + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(m + \mu n)</math> в противном случае.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
Программа, реализующая поиск транзитного замыкания, состоит CPU части, отвечающей за общую координацию вычислений, использующей вспомогательные классы.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

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

<references />

[[Категория:Начатые статьи]]