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

Widget:Algoviewer

2017-05-28T17:15:47Z

Lineprinter:

<noinclude>
Шаблон для вставки интерактивных графов алгоритмов.

Параметры:
* url (e.g. "Givens/Algo_viewer_example_1.html")
* width (default 400)
* height (default 300)
* border (default 0)

Пример:
<source lang="text">
{{#widget:Algoviewer
|url=Givens/giv3/Algo_view_givens3.html
|width=600
|height=600
|border=1
}}
</source>
{{#widget:Algoviewer
|url=Givens/giv3/Algo_view_givens3.html
|width=600
|height=600
|border=1
}}

</noinclude>
<includeonly>
<iframe src="https://algowiki-project.org/html/Algo_viewer_json/" frameborder="" width="" height=""></iframe>
</includeonly>

Алговики:Технический форум

2017-04-20T14:35:18Z

Lineprinter:

{{project internals nav}}

== Свежие на момент 2017-04-20 изменения ==
* [[Widget:Iframe]] заменен на [[Widget:Algoviewer]]
* Установлено расширение [https://www.mediawiki.org/wiki/Extension:Tabs Tabs]

— [[S:Contributions/Lineprinter|lineprinter]] 17:35, 20 апреля 2017 (MSK)

== Свежие на момент 2016-11-01 изменения ==
* Починен redirect loop на страницах с символами +, ', ", =, \.
* Mediawiki обновлена до 1.26.4.
* Появился [[Ш:Doc]] для документации шаблонов.
* Заполнен [[MediaWiki:Edittools]] на основе [[ru-wikipedia:MediaWiki:Edittools]].

— [[S:Contributions/Lineprinter|lineprinter]] 11:11, 1 ноября 2016 (MSK)

== Свежие на момент 2016-10-07 изменения ==
* Введен обязательный https.
* Сертификат заменен на Let's Encrypt'овский.
* Введена капча на регистрацию и на повторные попытки входа в систему.
* Открыта регистрация.
* Введены дополнительные, короткие, редиректы на неймспейсы:
** '''Ш''' и '''T''' для '''Ш'''аблонов ('''T'''emplate)
** '''К''' и '''C''' для '''К'''атегорий ('''C'''ategory)
** '''С''' и '''S''' для '''С'''лужебных ('''S'''pecial)
** '''U''' для пользователей ('''U'''ser)
** '''Ф''' и '''F''' для '''Ф'''айлов ('''F'''ile)
** '''А''' и '''A''' для '''А'''лговики ('''A'''lgowiki)
: Таким образом, на страницу [[Алговики:Общий форум]] можно попасть по [[А:Общий форум]], например.
* Появился новый [[Ш:Плашка]], который предполагается использовать для создания производных от него шаблонов (например [[Ш:Assignment]])

— [[S:Contributions/Lineprinter|lineprinter]] 14:27, 7 октября 2016 (MSK)

Алговики:Технический форум

2017-04-20T14:34:52Z

Lineprinter:

{{project internals nav}}

== Свежие на момент 2017-04-20 изменения ==
* [[Widget:Iframe]] заменен на [[Widget:Algoviewer]]
* Установлено расширение [https://www.mediawiki.org/wiki/Extension:Tabs Tabs]

== Свежие на момент 2016-11-01 изменения ==
* Починен redirect loop на страницах с символами +, ', ", =, \.
* Mediawiki обновлена до 1.26.4.
* Появился [[Ш:Doc]] для документации шаблонов.
* Заполнен [[MediaWiki:Edittools]] на основе [[ru-wikipedia:MediaWiki:Edittools]].

— [[S:Contributions/Lineprinter|lineprinter]] 11:11, 1 ноября 2016 (MSK)

== Свежие на момент 2016-10-07 изменения ==
* Введен обязательный https.
* Сертификат заменен на Let's Encrypt'овский.
* Введена капча на регистрацию и на повторные попытки входа в систему.
* Открыта регистрация.
* Введены дополнительные, короткие, редиректы на неймспейсы:
** '''Ш''' и '''T''' для '''Ш'''аблонов ('''T'''emplate)
** '''К''' и '''C''' для '''К'''атегорий ('''C'''ategory)
** '''С''' и '''S''' для '''С'''лужебных ('''S'''pecial)
** '''U''' для пользователей ('''U'''ser)
** '''Ф''' и '''F''' для '''Ф'''айлов ('''F'''ile)
** '''А''' и '''A''' для '''А'''лговики ('''A'''lgowiki)
: Таким образом, на страницу [[Алговики:Общий форум]] можно попасть по [[А:Общий форум]], например.
* Появился новый [[Ш:Плашка]], который предполагается использовать для создания производных от него шаблонов (например [[Ш:Assignment]])

— [[S:Contributions/Lineprinter|lineprinter]] 14:27, 7 октября 2016 (MSK)

Widget:Algoviewer

2017-04-20T14:33:45Z

Lineprinter: Защищена страница «Widget:Algoviewer» ([Редактирование=Разрешено только администраторам] (бессрочно) [Переименование=Разрешено только админис…

<noinclude>
* url (e.g. "Givens/Algo_viewer_example_1.html")
* border (default 0)
* width (default 400)
* height (default 300)
{{#widget:Algoviewer
|url=seq_par/Algo_view_seq_par4.html
|width=1300
|height=800
|border=1
}}
</noinclude>
<includeonly>
<iframe src="https://algowiki-project.org/html/Algo_viewer_json/" frameborder="" width="" height=""></iframe>
</includeonly>

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

2017-04-20T14:30:21Z

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

{{algorithm
| name = Метод Гивенса (вращений) QR-разложения квадратной матрицы
| serial_complexity = <math>2n^3</math>
| pf_height = <math>11n-16</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>n^2</math>
| output_data = <math>n^2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

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

{{Шаблон:Матрица_вращения}}

может быть определена парой индексов и одним параметром. Это позволяет в стандартной реализации метода Гивенса хранить результаты разложения на месте матрицы <math>A</math> без использования дополнительных массивов.
<math>QR</math>-разложение матрицы <math>A</math> может быть использовано в разных целях: как для решения СЛАУ вида <math>Ax = b</math>, так и в качестве одного из шагов так называемого <math>QR</math>-алгоритма нахождения собственных чисел матрицы.

На каждом шаге алгоритма две строки преобразуемой матрицы подвергаются преобразованию вращения. При этом параметр такого преобразования подбирается так, чтобы один из поддиагональных элементов преобразуемой матрицы стал нулевым. Сначала в нуль последовательно обращаются элементы 1-го столбца, затем 2-го, и т.д. до n-1-го, после чего получившаяся матрица - это и есть матрица <math>R</math>.
Сам шаг алгоритма распадается на две части: подбор параметра вращения и выполнение вращения над двумя строками матрицы. Поскольку слева от "рабочего" столбца элементы вращаемых строк равны 0, то там выполнять вращение не нужно. Вращение элементов строк в текущем столбце выполняется одновременно с подбором параметра вращения. Таким образом, вторая часть шага заключается в выполнении вращения двумерных векторов, составленных из элементов вращаемых строк в столбцах справа от "рабочего". Каждое такое вращение эквивалентно перемножению двух комплексных чисел (или в сумме 4 умножениям, 1 сложению и 1 вычитанию действительных), одно из которых имеет модуль 1.
Подбор параметра вращения по двум элементам "рабочего" столбца является более сложной операцией, что связано в том числе и с необходимостью минимизации влияния ошибок округления. Обычно для хранения матрицы вращения используется тангенс половинного угла <math>t</math>, с которым простыми формулами (т.н. "боевыми формулами тригонометрии") связаны косинус <math>c</math> и синус <math>s</math> самого угла:

<math>c = (1 - t^2)/(1 + t^2), s = 2t/(1 + t^2)</math>

Именно <math>t</math> обычно и хранится в соответствующем элементе массива.

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

Для получения <math>QR</math>-разложения квадратной матрицы <math>A</math> последнюю приводят к правой треугольной (<math>R</math> - от слова right) последовательностью умножений её слева на матрицы вращения <math>T_{1 2}, T_{1 3}, ..., T_{1 n}, T_{2 3}, T_{2 4}, ..., T_{2 n}, ... , T_{n-2 n}, T_{n-1 n}</math>.

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

В конце процесса имеем <math>R=T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2}A</math>.

Так как матрицы вращения унитарны, то естественно получается <math>Q=(T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2})^* =T_{1 2}^* T_{1 3}^* ...T_{1 n}^* T_{2 3}^* T_{2 4}^* ...T_{2 n}^* ...T_{n-2 n}^* T_{n-1 n}^*</math> и <math>A=QR</math>.

В вещественном случае матрицы вращения ортогональны и <math>Q=(T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2})^T =T_{1 2}^T T_{1 3}^T ...T_{1 n}^T T_{2 3}^T T_{2 4}^T ...T_{2 n}^T ...T_{n-2 n}^T T_{n-1 n}^T</math>.

Для завершения математического описания остаётся записать вычисление<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref> матрицы вращения <math>T_{i j}</math> и формулы её умножения на текущую промежуточную матрицу.

Пусть в позиции <math>(i,i)</math> преобразуемой матрицы стоит число <math>x</math>, а в позиции <math>(i,j)</math> - число <math>y</math>.

Тогда для минимизации влияния ошибок округления сначала вычисляется равномерная норма вектора <math>z = max (|x|,|y|)</math>.

Если она равна 0, то поворот не требуется: <math>t=s=0, c=1</math>.

Если <math>z=|x|</math>, то вычисляем <math>y_1=y/x</math> и далее <math>c = \frac {1}{\sqrt{1+y_1^2}}</math>, <math>s=-c y_1</math>, <math>t=\frac {1-\sqrt{1+y_1^2}}{y_1}</math>, а в позиции <math>(i,i)</math> после поворота будет число <math>x \sqrt{1+y_1^2}</math>.

Если же <math>z=|y|</math>, то вычисляем <math>x_1=x/y</math> и далее <math>t=x_1 - x_1^2 sign(x_1)</math>, <math>s=\frac{sign(x_1)}{\sqrt{1+x_1^2}}</math>, <math>c = s x_1</math>, а в позиции <math>(i,i)</math> после поворота будет число <math>y \sqrt{1+x_1^2} sign(x)</math>.

После получения элементов <math>c</math> и <math>s</math> матрицы вращения <math>T_{i j}</math> запись преобразования для каждого столбца правее <math>i</math>-го выглядит просто. Если в <math>k</math>-м столбце в позиции c номером <math>i</math> стоит x, а в позиции с номером <math>j</math> стоит y, то их новые значения будут <math>cx - sy</math> и <math>sx + cy</math>, соответственно, как если бы комплексное число с действительной частью <math>x</math> и мнимой <math>y</math> умножили на комплексное число <math>(c,s)</math>.

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

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

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

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

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

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

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

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

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

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

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

=== Информационный граф ===
Макрограф алгоритма изображён на рисунке 1, графы макровершин - на последующих.

[[file:QRGivens2.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=4. F1 - операция вычисления параметров поворота, F2 - выполнение поворота 2-мерного вектора (эквивалентно операции умножения двух комплексных чисел).]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:F1-full.png|Рисунок 2. Выбор метода вычисления параметров поворота в вершинах F1.
File:Givens F1!=.png|Рисунок 3. Вычисление параметров поворота для различных x и y в вершине V2.
File:Givens F1==.png|Рисунок 4. Вычисление параметров поворота для одинаковых x и у в вершине V1.
</gallery>
</div>
</div>

<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=300px>
File:Givens F1=0.png|Рисунок 5. Вычисление параметров поворота для нулевых x и у в вершине V0.
File:Povorot-complexmult.png|Рисунок 6. Внутренний граф вершин F2 с входными и выходными параметрами: (u,v) = (c,s)(x,y)
</gallery>
</div>
</div>
</center>

<center>
<tabs>
<tab name="n=3">
{{#widget:Algoviewer
|url=Givens/giv3/Algo_view_givens3.html
|width=1300
|height=800
|border=1
}}
</tab>
<tab name="n=4">
{{#widget:Algoviewer
|url=Givens/giv4/Algo_view_givens4.html
|width=1300
|height=800
|border=1
}}
</tab>
</tabs>
</center>

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

Как видно из описания подграфов, макровершина вычисления параметров поворота F1 в графе намного "весомее" вершины поворота F2.
А именно, в макровершине поворота критический путь - всего-навсего одно умножение (их 4, но все можно выполнить параллельно) и одно сложение/вычитание (их 2, но они тоже параллельны). Макровершина же вычисления параметров даёт в худшем случае критический путь, в котором одно вычисление квадратного корня, и по две операции деления, умножения, сложения/вычитания.

Поэтому по грубой оценке критический путь в основном будет идти через <math>2n-3</math> макровершины вычисления параметров F1, а также через <math>n-1</math> макровершин поворотов. В сумме это даёт критический путь, проходящий по <math>2n-3</math> операциям вычисления квадратного корня, <math>4n-6</math> делениям, по <math>5n-7</math> умножениям и сложениям/вычитаниям. В макрографе, представленном на рисунке, один из критических путей может быть представлен, например, как прохождение по "верхней линии" вершин F1 (это <math>n-1</math> штук) и затем попеременное выполнение F2 и F1 (<math>n-2</math> раза), после чего ещё одно выполнение F2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В простейшем варианте метод Гивенса (вращений) QR-разложения квадратной вещественной матрицы на Фортране можно записать так:
<source lang="fortran">
DO I = 1, N-1
DO J = I+1, N
CALL PARAMS (A(I,I), A(J,I), C, S)
DO K = I+1, N
CALL ROT2D (C, S, A(I,K), A(J,K))
END DO
END DO
END DO
</source>

Подпрограмма вращения ROT2D может быть записана, если операции с комплексными числами реализованы в трансляторе грамотно, так:

<source lang="fortran">
SUBROUTINE ROT2D (C, S, X, Y)
COMPLEX Z
REAL ZZ(2)
EQUIVALENCE Z, ZZ
Z = CMPLX(C, S)*CMPLX(X,Y)
X = ZZ(1)
Y = ZZ(2)
RETURN
END
</source>

или же так:

<source lang="fortran">
SUBROUTINE ROT2D (C, S, X, Y)
ZZ = C*X - S*Y
Y = S*X + C*Y
X = ZZ
RETURN
END
</source>

(с точки зрения графа алгоритма эти записи эквивалентны).

Подпрограмма вычисления параметров вращения может быть такой:

<source lang="fortran">
SUBROUTINE PARAMS (X, Y, C, S)
Z = MAX (ABS(X), ABS(Y))
IF (Z.EQ.0.) THEN
C OR (Z.LE.OMEGA) WHERE OMEGA - COMPUTER ZERO
C = 1.
S = 0.
ELSE IF (Z.EQ.ABS(X))
R = Y/X
RR = R*R
RR2 = SQRT(1+RR)
X = X*RR2
Y = (1-RR2)/R
C = 1./RR2
S = -C*R
ELSE
R = X/Y
RR = R*R
RR2 = SQRT (1+RR)
X = SIGN(Y, X)*RR
Y = R - SIGN(RR,R)
S = SIGN(1./RR2, R)
C = S*R
END IF
RETURN
END
</source>

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

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

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

На рис. 7 представлен профиль обращений в память для реализации вещественного варианта метода Гивенса (вращений) QR-разложения квадратной матрицы. Данный профиль состоит из обращений к одному двумерному массиву, в котором хранится матрица значений. Из данного графика можно увидеть наличие однотипных итераций, из которых профиль и состоит. <math>i</math>-я итерация затрагивает элементы массива, начиная с <math>(i-1)*k</math>, то есть после каждой итерации первые <math>k</math> элементов (значение <math>k</math> нам пока неизвестно) больше не рассматриваются. Каждая итерация состоит из двух параллельно выполняемых частей – последовательного перебора всех элементов, начиная с <math>(i-1)*k</math>, и активного использования первых <math>i*k</math> элементов.

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

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

[[file:givens_2.png|thumb|center|700px|Рисунок 8. Выделенный фрагмент общего профиля]]

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

[[file:givens_3.png|thumb|center|700px|Рисунок 9. Фрагмент общего профиля, дальнейшее приближение]]

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

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

Основной фрагмент реализации, с помощью которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/givens/givens.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поиски по известным пакетам программ привели к неожиданному результату <ref>Фролов А.В., Антонов А.С., Воеводин Вл.В., Теплов А.М. Сопоставление разных методов решения одной задачи по методике проекта Algowiki // Подана на конференцию "Параллельные вычислительные технологии (ПаВТ'2016)".</ref>. Несмотря на то, что в большинстве старых "последовательных" пакетов как правило наличествует и программа QR-разложения методом Гивенса, в новых, рассчитанных на параллельное исполнение, пакетах QR-разложение осуществляют только с помощью [[Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант|метода Хаусхолдера (отражений)]], который именно по параллельным свойствам проигрывает методу Гивенса. Мы связываем это с тем, что [[Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант|метод Хаусхолдера (отражений)]] легко записывается через BLAS-процедуры и не требует переупорядочивания обычного хода циклов (разве что при введении блочности, но это не "косая", а координатная нарезка циклов), а вот для параллельной реализации метода Гивенса (вращений) не избежать перезаписи циклов, поскольку максимально параллельный вариант в нём требует применения [[Глоссарий#Скошенный параллелизм|cкошенного (в узком понимании этого термина) параллелизма]]. Поэтому временно описание масштабируемости реализаций данного алгоритма невозможно - пока нет материала для исследования этой масштабируемости.

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

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

[[En: Givens method]]

Перемножение плотных неособенных матриц (последовательный вещественный вариант)

2017-04-20T06:54:35Z

Lineprinter:

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

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

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

'''Перемножение матриц''' - одна из базовых задач в алгоритмах линейной алгебры, широко применяется в большом количестве разных методов.
Здесь мы рассмотрим умножение <math>C = AB</math>  плотных неособенных матриц (последовательный вещественный вариант), то есть тот вариант, где никак не используются ни специальный вид матрицы, ни ассоциативные свойства операции сложения<ref>В.В.Воеводин, Ю.А.Кузнецов. Матрицы и вычисления. М.: Наука, 1984.</ref>.

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

Исходные данные: плотная матрица <math>A</math> (элементы <math>a_{ij}</math>), плотная матрица <math>B</math> (элементы <math>b_{ij}</math>).

Вычисляемые данные: плотная матрица <math>C</math> (элементы <math>c_{ij}</math>).

Формулы метода:
:<math>
\begin{align}
c_{ij} = \sum_{k = 1}^{n} a_{ik} b_{kj}, \quad i \in [1, m], \quad i \in [1, l].
\end{align}
</math>

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

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

Вычислительное ядро перемножения плотных неособенных матриц можно составить из множественных (всего их <math>l</math>) вычислений умножения матрицы <math>A</math> на столбцы матрицы <math>B</math>, или (при более детальном рассмотрении), из множественных (всего их <math>ml</math>) скалярных произведений строк матрицы <math>A</math> на столбцы матрицы <math>B</math>:

:<math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math>

в режиме накопления или без него, в зависимости от требований задачи.

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

Как уже записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть умножения матриц составляют множественные (всего <math>ml</math>) вычисления скалярных произведений строк матрицы <math>A</math> на столбцы матрицы <math>B</math>

:<math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math>

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

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

Для всех <math>i</math> от <math>1</math> до <math>m</math> и для всех <math>j</math> от <math>1</math> до <math>l</math> выполняются

:<math>c_{ij} = \sum_{k = 1}^{n} a_{ik} b_{kj}</math>

Особо отметим, что вычисления сумм вида <math>\sum_{k = 1}^{n} a_{ik} b_{kj}</math> производят в режиме накопления прибавлением к текущему (временному) значению вычисляемого элемента матрицы <math>c_{ij}</math> произведений <math>a_{ik} b_{kj}</math> для <math>k</math> от <math>1</math> до <math>n</math>, '''c возрастанием''' <math>k</math>, вначале все элементы инициализируются нулями. При суммировании "по убыванию" общая схема принципиально не отличается и потому нами не рассматривается. Другие порядки выполнения суммирования приводят к изменению параллельных свойств алгоритма и будут рассматриваться нами в отдельных описаниях.

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

Для умножения двух квадратных матриц порядка <math>n</math> (т.е. при <math>m=n=l</math>) в последовательном (наиболее быстром) варианте требуется:

* по <math>n^3</math> умножений и сложений.

Для умножения матрицы размером <math>m</math> строк на <math>n</math> столбцов на матрицу размером <math>m</math> строк на <math>n</math> столбцов в последовательном (наиболее быстром) варианте требуется:

* по <math>mnl</math> умножений и сложений.

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

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

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]] как аналитически, так и в виде рисунка.

Граф алгоритма умножения плотных матриц состоит из одной группы вершин, расположенной в целочисленных узлах трёхмерной области, соответствующая ей операция <math>a+bc</math>.

Естественно введённые координаты области таковы:
* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>m</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>l</math>, принимая все целочисленные значения;
* <math>k</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения.

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

Результат срабатывания операции является:
* при <math>k < n</math> - ''промежуточным данным'' алгоритма;
* при <math>k = n</math> - выходным данным <math>c_{ij}</math>.

[[file:Dense mtrx product.png|thumb|center|800px|Рисунок 1. Умножение плотных матриц с отображением выходных данных]]
<br/>

<center>
Интерактивное изображение графа алгоритма без входных и выходных данных для случая перемножения двух квадратных матриц порядка 3 и 4
</center>

<center>
{{#widget:Algoviewer
|url=mat_mul/mat_mul_3/Algo_view_matrix3.html
|width=1300
|height=800
|border=1
}}

{{#widget:Algoviewer
|url=mat_mul/mat_mul_4/Algo_view_matrix4.html
|width=1300
|height=800
|border=1
}}

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

Для алгоритма умножения квадратных матриц порядка n в параллельном варианте требуется последовательно выполнить следующие ярусы:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n^2</math> операций).

Для умножения матрицы размером <math>m</math> строк на <math>n</math> столбцов на матрицу размером <math>n</math> строк на <math>l</math> столбцов в последовательном (наиболее быстром) варианте требуется:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>ml</math> операций).

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

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

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

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

'''Объём входных данных''': <math>mn+nl</math>

'''Выходные данные''': матрица <math>C</math> (элементы <math>c_{ij}</math>).

'''Объём выходных данных''': <math>ml</math>

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

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

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

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

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

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

В простейшем варианте алгоритм умножения матриц на Фортране можно записать так:

<source lang="fortran">

DO I = 1, M
DO J = 1, L
S = 0.
DO K = 1, N
S = S + DPROD(A(I,K), B(K,J))
END DO
C(I, J) = S
END DO
END DO
</source>
При этом для реализации режима накопления переменная <math>S</math> должна быть двойной точности.

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

[[file:matrmult 1.PNG|thumb|center|700px|Рисунок 2. Профили обращений для 6 вариантов перемножения матриц]]

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

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

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

Рассмотрим подробнее каждый из данных 6 фрагментов на примере массива С.

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

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

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

[[file:matrmult 2.PNG|thumb|center|700px|Рисунок 3. Начало фрагмента 1]]
[[file:matrmult 3.PNG|thumb|center|700px|Рисунок 4. Начало фрагмента 1, первые 3 итерации]]

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

[[file:matrmult 4.PNG|thumb|center|700px|Рисунок 5. Начало фрагмента 2]]
[[file:matrmult 5.PNG|thumb|center|700px|Рисунок 6. Начало фрагмента 2, часть первой итерации]]

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

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

[[file:matrmult 6.PNG|thumb|center|700px|Рисунок 7. Начало фрагмента 3]]
[[file:matrmult 7.PNG|thumb|center|700px|Рисунок 8. Начало фрагмента 3, первые несколько обращений]]

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

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

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

[[file:matrmult 8.PNG|thumb|center|700px|Рисунок 9. Начало фрагмента 4]]

'''Фрагмент 5.''' В отличие от предыдущих фрагментов, исходя из визуализации начала данного фрагмента (рис.9), сложно сделать выводы относительно структуры обращения в память. Однако более подробное рассмотрение (рис.10) показывает, что данный профиль практически идентичен профилю предыдущего фрагмента. Более того, фрагмент 5 на самом деле состоит из итерационно повторяющихся фрагментов 4.

[[file:matrmult 9.PNG|thumb|center|700px|Рисунок 10. Начало фрагмента 5]]
[[file:matrmult 10.PNG|thumb|center|700px|Рисунок 11. Начало фрагмента 5, первые несколько итераций]]

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

'''Фрагмент 6.''' Данный фрагмент, представленный на рис.12 и рис.13, так же сильно напоминает фрагмент 5, но с одним отличием. Во фрагменте 5 несколько раз повторяется фрагмент 4, в рамках которого выполняется несколько итераций, и на каждой итерации внутри фрагмента 4 используются разные элементы (поскольку первый элемент сдвигается на 1). В случае данного фрагмента выполняются все те же итерации, но в перемешанном виде. Сначала выполняются все итерации, начинающиеся с одного и того же элемента; затем все итерации, который начинаются с элемента, чей индекс идет следующим; и т.д.

Такой фрагмент обладает более высокой и пространственной, и временно́й локальностью по сравнению с фрагментом 5, поскольку обращения в одним и тем же элементам расположены ближе друг к другу в профиле.

[[file:matrmult 11.PNG|thumb|center|700px|Рисунок 12. Начало фрагмента 6]]
[[file:matrmult 12.PNG|thumb|center|700px|Рисунок 13. Начало фрагмента 6, первые несколько итераций]]

В итоге можно сказать, что наиболее низкой локальностью в целом обладают фрагменты 5 и 6. Фрагмент 4 также обладает низкой локальностью, однако содержит значительно меньшее число обращений, а значит, привносит меньший вклад в общий профиль обращений. Это позволяет определить, что наименее эффективными с точки зрения работы с памятью являются варианты kji и jki, поскольку каждый из них содержит фрагменты 5 и 6. Далее идут варианты ijk и jik – в них по одному такому фрагменту. Самые лучшие варианты – ikj и kij.

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

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

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

На рис.14 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что, как и предполагалось наиболее эффективными являются варианты kij,ikj. Заметно хуже результат у вариантов jik,ijk, при этом эти варианты практически равны между собой. Самый плохой результат ожидаемо у вариантов jki,kji.

[[file:matrmult daps ru.PNG|thumb|center|700px|Рисунок 14. Сравнение значений оценки daps]]

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

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

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

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

[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рисунок 16. Параллельная реализация произведения матриц Максимальная производительность. ]]
[[file:Масштабируемость параллельной реализации перемножения матриц Эффективность.png|thumb|center|700px|Рисунок 17. Параллельная реализация произведения матриц Максимальная эффективность. ]]
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:
* число процессоров [4 : 1024]
* размерность матрицы [1024 : 20480]
Эффективность выполнения реализации алгоритма
* Минимальная эффективность 4,71%
* Максимальная эффективность 31,72%
Оценка масштабируемости
* По числу процессов: -0.0436 – при увеличении числа процессов эффективность убывает достаточно интенсивно на всей рассмотренной области изменений параметров запуска. Уменьшение эффективности на рассмотренной области работы параллельной программы звязано с увеличением числа пересылок с ростом числа процессов и как следствие ростом накладных расходов на организацию вычислений. Присутствует область, на которой при увеличении числа процессов эффективность возрастает, но при дальнейшем росте продолжает снижаться. Это объясняется декомпозицей данных, при которой наступает момент, когда размер матрицы позволяет блокам укладываться в КЭШ-память. Так же это подтверждает проявление этого явления, но со смещением по числу процессов, и при увеличении вычислительной сложности задачи.
* По размеру задачи: -0.0255 – при увеличении размера задачи эффективность в целом уменьшается по рассматриваемой области, хотя и менее интенсивно, чем при увеличении числа процессов. Снижение эффективности объясняется тем, что при росте вычислительной сложности существенно возрастают объемы передаваемых данных. Присутствует область возрастания эффективности, на всех рассмотренных размерах матрицы. Это объясняется тем, что при малом размере задачи данные хорошо укладываются в КЭШ память, что приводит к высокой эффективности работы приложения при малом размере задачи. При дальнейшем увеличении размера эффективность уменьшается при выходе за границы КЭШ-памяти.
* По двум направлениям: -0.000968 – при рассмотрении увеличения, как вычислительной сложности, так и числа процессов по всей рассмотренной области значений уменьшается, интенсивность уменьшения эффективности не очень высока. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров составляет почти 25% говорит о том, что уменьшение эффективности по всей области довольно равномерное, но интенсивно лишь в не очень больших участках по площади. На остальной области значений параметров изменения эффективности не столь значительны и находятся на приблизительно одном и том же уровне.

[http://git.algowiki-project.org/Teplov/Scalability/blob/master/matrixmult/matrixmult.c Реализация алгоритма на языке C].

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

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

[[Категория:Законченные статьи]]
[[Категория:Матричные операции]]

[[En:Dense matrix multiplication]]

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

2017-04-20T06:54:17Z

Lineprinter:

{{algorithm
| name = Метод Гивенса (вращений) QR-разложения квадратной матрицы
| serial_complexity = <math>2n^3</math>
| pf_height = <math>11n-16</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>n^2</math>
| output_data = <math>n^2</math>
}}
Основные авторы описания: [[Участник:Frolov|А.В.Фролов]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

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

{{Шаблон:Матрица_вращения}}

может быть определена парой индексов и одним параметром. Это позволяет в стандартной реализации метода Гивенса хранить результаты разложения на месте матрицы <math>A</math> без использования дополнительных массивов.
<math>QR</math>-разложение матрицы <math>A</math> может быть использовано в разных целях: как для решения СЛАУ вида <math>Ax = b</math>, так и в качестве одного из шагов так называемого <math>QR</math>-алгоритма нахождения собственных чисел матрицы.

На каждом шаге алгоритма две строки преобразуемой матрицы подвергаются преобразованию вращения. При этом параметр такого преобразования подбирается так, чтобы один из поддиагональных элементов преобразуемой матрицы стал нулевым. Сначала в нуль последовательно обращаются элементы 1-го столбца, затем 2-го, и т.д. до n-1-го, после чего получившаяся матрица - это и есть матрица <math>R</math>.
Сам шаг алгоритма распадается на две части: подбор параметра вращения и выполнение вращения над двумя строками матрицы. Поскольку слева от "рабочего" столбца элементы вращаемых строк равны 0, то там выполнять вращение не нужно. Вращение элементов строк в текущем столбце выполняется одновременно с подбором параметра вращения. Таким образом, вторая часть шага заключается в выполнении вращения двумерных векторов, составленных из элементов вращаемых строк в столбцах справа от "рабочего". Каждое такое вращение эквивалентно перемножению двух комплексных чисел (или в сумме 4 умножениям, 1 сложению и 1 вычитанию действительных), одно из которых имеет модуль 1.
Подбор параметра вращения по двум элементам "рабочего" столбца является более сложной операцией, что связано в том числе и с необходимостью минимизации влияния ошибок округления. Обычно для хранения матрицы вращения используется тангенс половинного угла <math>t</math>, с которым простыми формулами (т.н. "боевыми формулами тригонометрии") связаны косинус <math>c</math> и синус <math>s</math> самого угла:

<math>c = (1 - t^2)/(1 + t^2), s = 2t/(1 + t^2)</math>

Именно <math>t</math> обычно и хранится в соответствующем элементе массива.

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

Для получения <math>QR</math>-разложения квадратной матрицы <math>A</math> последнюю приводят к правой треугольной (<math>R</math> - от слова right) последовательностью умножений её слева на матрицы вращения <math>T_{1 2}, T_{1 3}, ..., T_{1 n}, T_{2 3}, T_{2 4}, ..., T_{2 n}, ... , T_{n-2 n}, T_{n-1 n}</math>.

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

В конце процесса имеем <math>R=T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2}A</math>.

Так как матрицы вращения унитарны, то естественно получается <math>Q=(T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2})^* =T_{1 2}^* T_{1 3}^* ...T_{1 n}^* T_{2 3}^* T_{2 4}^* ...T_{2 n}^* ...T_{n-2 n}^* T_{n-1 n}^*</math> и <math>A=QR</math>.

В вещественном случае матрицы вращения ортогональны и <math>Q=(T_{n-1 n}T_{n-2 n}T_{n-2 n-1}...T_{1 3}T_{1 2})^T =T_{1 2}^T T_{1 3}^T ...T_{1 n}^T T_{2 3}^T T_{2 4}^T ...T_{2 n}^T ...T_{n-2 n}^T T_{n-1 n}^T</math>.

Для завершения математического описания остаётся записать вычисление<ref name="VOLA">Воеводин В.В. Вычислительные основы линейной алгебры. М.: Наука, 1977.</ref> матрицы вращения <math>T_{i j}</math> и формулы её умножения на текущую промежуточную матрицу.

Пусть в позиции <math>(i,i)</math> преобразуемой матрицы стоит число <math>x</math>, а в позиции <math>(i,j)</math> - число <math>y</math>.

Тогда для минимизации влияния ошибок округления сначала вычисляется равномерная норма вектора <math>z = max (|x|,|y|)</math>.

Если она равна 0, то поворот не требуется: <math>t=s=0, c=1</math>.

Если <math>z=|x|</math>, то вычисляем <math>y_1=y/x</math> и далее <math>c = \frac {1}{\sqrt{1+y_1^2}}</math>, <math>s=-c y_1</math>, <math>t=\frac {1-\sqrt{1+y_1^2}}{y_1}</math>, а в позиции <math>(i,i)</math> после поворота будет число <math>x \sqrt{1+y_1^2}</math>.

Если же <math>z=|y|</math>, то вычисляем <math>x_1=x/y</math> и далее <math>t=x_1 - x_1^2 sign(x_1)</math>, <math>s=\frac{sign(x_1)}{\sqrt{1+x_1^2}}</math>, <math>c = s x_1</math>, а в позиции <math>(i,i)</math> после поворота будет число <math>y \sqrt{1+x_1^2} sign(x)</math>.

После получения элементов <math>c</math> и <math>s</math> матрицы вращения <math>T_{i j}</math> запись преобразования для каждого столбца правее <math>i</math>-го выглядит просто. Если в <math>k</math>-м столбце в позиции c номером <math>i</math> стоит x, а в позиции с номером <math>j</math> стоит y, то их новые значения будут <math>cx - sy</math> и <math>sx + cy</math>, соответственно, как если бы комплексное число с действительной частью <math>x</math> и мнимой <math>y</math> умножили на комплексное число <math>(c,s)</math>.

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

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

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

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

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

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

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

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

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

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

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

=== Информационный граф ===
Макрограф алгоритма изображён на рисунке 1, графы макровершин - на последующих.

[[file:QRGivens2.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=4. F1 - операция вычисления параметров поворота, F2 - выполнение поворота 2-мерного вектора (эквивалентно операции умножения двух комплексных чисел).]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:F1-full.png|Рисунок 2. Выбор метода вычисления параметров поворота в вершинах F1.
File:Givens F1!=.png|Рисунок 3. Вычисление параметров поворота для различных x и y в вершине V2.
File:Givens F1==.png|Рисунок 4. Вычисление параметров поворота для одинаковых x и у в вершине V1.
</gallery>
</div>
</div>

<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=300px>
File:Givens F1=0.png|Рисунок 5. Вычисление параметров поворота для нулевых x и у в вершине V0.
File:Povorot-complexmult.png|Рисунок 6. Внутренний граф вершин F2 с входными и выходными параметрами: (u,v) = (c,s)(x,y)
</gallery>
</div>
</div>
</center>

<center>
{{#widget:Algoviewer
|url=Givens/giv3/Algo_view_givens3.html
|width=1300
|height=800
|border=1
}}

{{#widget:Algoviewer
|url=Givens/giv4/Algo_view_givens4.html
|width=1300
|height=800
|border=1
}}

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

Как видно из описания подграфов, макровершина вычисления параметров поворота F1 в графе намного "весомее" вершины поворота F2.
А именно, в макровершине поворота критический путь - всего-навсего одно умножение (их 4, но все можно выполнить параллельно) и одно сложение/вычитание (их 2, но они тоже параллельны). Макровершина же вычисления параметров даёт в худшем случае критический путь, в котором одно вычисление квадратного корня, и по две операции деления, умножения, сложения/вычитания.

Поэтому по грубой оценке критический путь в основном будет идти через <math>2n-3</math> макровершины вычисления параметров F1, а также через <math>n-1</math> макровершин поворотов. В сумме это даёт критический путь, проходящий по <math>2n-3</math> операциям вычисления квадратного корня, <math>4n-6</math> делениям, по <math>5n-7</math> умножениям и сложениям/вычитаниям. В макрографе, представленном на рисунке, один из критических путей может быть представлен, например, как прохождение по "верхней линии" вершин F1 (это <math>n-1</math> штук) и затем попеременное выполнение F2 и F1 (<math>n-2</math> раза), после чего ещё одно выполнение F2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В простейшем варианте метод Гивенса (вращений) QR-разложения квадратной вещественной матрицы на Фортране можно записать так:
<source lang="fortran">
DO I = 1, N-1
DO J = I+1, N
CALL PARAMS (A(I,I), A(J,I), C, S)
DO K = I+1, N
CALL ROT2D (C, S, A(I,K), A(J,K))
END DO
END DO
END DO
</source>

Подпрограмма вращения ROT2D может быть записана, если операции с комплексными числами реализованы в трансляторе грамотно, так:

<source lang="fortran">
SUBROUTINE ROT2D (C, S, X, Y)
COMPLEX Z
REAL ZZ(2)
EQUIVALENCE Z, ZZ
Z = CMPLX(C, S)*CMPLX(X,Y)
X = ZZ(1)
Y = ZZ(2)
RETURN
END
</source>

или же так:

<source lang="fortran">
SUBROUTINE ROT2D (C, S, X, Y)
ZZ = C*X - S*Y
Y = S*X + C*Y
X = ZZ
RETURN
END
</source>

(с точки зрения графа алгоритма эти записи эквивалентны).

Подпрограмма вычисления параметров вращения может быть такой:

<source lang="fortran">
SUBROUTINE PARAMS (X, Y, C, S)
Z = MAX (ABS(X), ABS(Y))
IF (Z.EQ.0.) THEN
C OR (Z.LE.OMEGA) WHERE OMEGA - COMPUTER ZERO
C = 1.
S = 0.
ELSE IF (Z.EQ.ABS(X))
R = Y/X
RR = R*R
RR2 = SQRT(1+RR)
X = X*RR2
Y = (1-RR2)/R
C = 1./RR2
S = -C*R
ELSE
R = X/Y
RR = R*R
RR2 = SQRT (1+RR)
X = SIGN(Y, X)*RR
Y = R - SIGN(RR,R)
S = SIGN(1./RR2, R)
C = S*R
END IF
RETURN
END
</source>

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

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

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

На рис. 7 представлен профиль обращений в память для реализации вещественного варианта метода Гивенса (вращений) QR-разложения квадратной матрицы. Данный профиль состоит из обращений к одному двумерному массиву, в котором хранится матрица значений. Из данного графика можно увидеть наличие однотипных итераций, из которых профиль и состоит. <math>i</math>-я итерация затрагивает элементы массива, начиная с <math>(i-1)*k</math>, то есть после каждой итерации первые <math>k</math> элементов (значение <math>k</math> нам пока неизвестно) больше не рассматриваются. Каждая итерация состоит из двух параллельно выполняемых частей – последовательного перебора всех элементов, начиная с <math>(i-1)*k</math>, и активного использования первых <math>i*k</math> элементов.

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

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

[[file:givens_2.png|thumb|center|700px|Рисунок 8. Выделенный фрагмент общего профиля]]

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

[[file:givens_3.png|thumb|center|700px|Рисунок 9. Фрагмент общего профиля, дальнейшее приближение]]

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

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

Основной фрагмент реализации, с помощью которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/givens/givens.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поиски по известным пакетам программ привели к неожиданному результату <ref>Фролов А.В., Антонов А.С., Воеводин Вл.В., Теплов А.М. Сопоставление разных методов решения одной задачи по методике проекта Algowiki // Подана на конференцию "Параллельные вычислительные технологии (ПаВТ'2016)".</ref>. Несмотря на то, что в большинстве старых "последовательных" пакетов как правило наличествует и программа QR-разложения методом Гивенса, в новых, рассчитанных на параллельное исполнение, пакетах QR-разложение осуществляют только с помощью [[Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант|метода Хаусхолдера (отражений)]], который именно по параллельным свойствам проигрывает методу Гивенса. Мы связываем это с тем, что [[Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный вариант|метод Хаусхолдера (отражений)]] легко записывается через BLAS-процедуры и не требует переупорядочивания обычного хода циклов (разве что при введении блочности, но это не "косая", а координатная нарезка циклов), а вот для параллельной реализации метода Гивенса (вращений) не избежать перезаписи циклов, поскольку максимально параллельный вариант в нём требует применения [[Глоссарий#Скошенный параллелизм|cкошенного (в узком понимании этого термина) параллелизма]]. Поэтому временно описание масштабируемости реализаций данного алгоритма невозможно - пока нет материала для исследования этой масштабируемости.

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

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

[[En: Givens method]]

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

2017-04-20T06:53:43Z

Lineprinter:

{{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:Algoviewer
|url=cholesky/Algo_view_cholesky4.html
|width=1300
|height=800
|border=1
}}
<br/>
Интерактивное изображение графа алгоритма без входных и выходных данных для 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]]

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

Widget:Algoviewer

2017-04-20T06:52:43Z

Lineprinter:

Widget:Algoviewer

2017-04-20T06:52:25Z

Lineprinter:

<noinclude>
* url (e.g. "Givens/Algo_viewer_example_1.html")
* border (default 0)
* width (default 400)
* height (default 300)
{{#widget:Algoviewer
|url=seq_par/Algo_view_seq_par4.html
|width=1300
|height=800
|border=1
}}
</noinclude>
<includeonly>
<iframe src="https://algowiki-project.org/html/Algo_viewer_json/" frameborder="" width="" height=""></iframe>
</includeonly>

Последовательно-параллельный метод суммирования

2017-04-20T06:51:24Z

Lineprinter:

Widget:Algoviewer

2017-04-20T06:50:22Z

Lineprinter:

Widget:Algoviewer

2017-04-20T06:48:43Z

Lineprinter: Новая страница: «<noinclude> * url (e.g. "Givens/Algo_viewer_example_1.html") * border (default 0) * width (default 400) * height (default 300) {{#widget:Algoviewer |url=seq_par/A…»

<noinclude>
* url (e.g. "Givens/Algo_viewer_example_1.html")
* border (default 0)
* width (default 400)
* height (default 300)
{{#widget:Algoviewer
|url=seq_par/Algo_view_seq_par4.html
|width=1300
|height=800
|border=1
}}
</noinclude>
<includeonly>
<iframe src="https://algowiki-project.org/html/Algo_viewer_json/" frameborder="" width="" height=""></iframe>
</includeonly>

Участница:Эльвира Ахиярова/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-16T18:17:02Z

Lineprinter:

{{Assignment}}

{{algorithm
| name = Обобщеннный метод минимальных невязок
| serial_complexity = <math>O(mn+m^2+n^2)</math>
| input_data = <math>n^2+n+1</math>
| output_data = <math>n</math>
}}
Основные авторы описания: [[Участник:Эльвира Ахиярова|Э.А.Ахиярова]]

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

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

Обобщенный метод минимальных невязок (GMRES) - это итерационный метод для нахождения приближенного решения системы линейных алгебраических уравнений <math>Ax = b </math> с произвольной матрицей <math>A</math>. Алгоритм был преложен в 1986 году Йозефом Саадом и Мартином Г. Шульцем
<ref>Y. Saad and M.H. Schultz, "GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems", SIAM J. Sci. Stat. Comput., 7:856-869, 1986. doi:10.1137/0907058.</ref>.

В то время как применение классических итерационных алгоритмов для решения СЛАУ ограничивается либо диагональным преобладанием, либо положительной определенностью матрицы, GMRES может быть использован для систем с произвольной невырожденной матрицей <math>A</math>. Данный метод опирается на итерации Арнольди для нахождения минимизирующего невязку вектора из подпространства Крылова <ref>https://en.wikipedia.org/wiki/Krylov_subspace</ref>.

Основным недостатком метода GMRES является поитерационное увеличение объема требуемой памяти. В связи с этим, для некоторых вычислительных систем выполенние программы метода может быть невозможным. Для некоторых систем используют модифицированный обобщенный метод минимальных невязок - GMRES(m), который подразумевает использование рестартов, существенно сокращающих объемы необходимой памяти.

Ключевая идея обобщенного метода минимальных невязок основана на решении задачи наименьших квадратов на каждом итерационном шаге. На каждом <math>k</math>-м шаге точное решение <math>x^* = A^{-1}b </math> аппроксимируется вектором <math>x_k \in K_k</math>, таким образом, что:
:<math>
\|r_k{\|}_2 = \|Ax_k-b{\|}_2 \to \min
</math>,
где <math>K_k</math> - подпространство Крылова <math> k </math> - го порядка.

=== Математическое описание алгоритма ===
'''Исходные данные:''' Матрица <math>A \in R^{n\times n}</math>, вектор правой части <math>b \in R^n</math>.

'''Вычисляемые данные:''' Приближенное решение <math>\tilde{x} \in R^n</math> системы <math>Ax = b</math>.

На каждом <math>k</math>-м шаге метода решение <math>x_k</math> рассматривается в виде <math>x_0+Vy_k</math>, где столбцы <math>v_k</math> матрицы <math>V</math> находятся с помощью процесса Арнольди для построения ортонормированного базиса <math>\{v_1, v_2, \dots, v_k\}</math> подпространства Крылова <math>K_k(A, v_1)</math>,
вектор <math>y_k</math> представляет собой решение системы <math>H_ky_k = \beta_k e_1</math>, где <math>H_k</math> - верхняя матрица Хессенберга<ref>https://en.wikipedia.org/wiki/Hessenberg_matrix</ref> размера <math>k\times k</math>, элементы которой формируются в процессе ортогонализации Арнольди, <math>\beta_k = \|r_0{\|}_2, \ r_0 = b - Ax_0 </math>, и, наконец, <math>e_1</math> - канонический вектор <math>{\begin{pmatrix}1&0&\dots 0\end{pmatrix}}^T</math> размерности <math>k</math>

Рассмотрим подробнее процесс ортогонализации Арнольди:

==== Процесс Арнольди ====
'''Исходные данные:''' начальный ортонормированный вектор <math>v_1</math> и размерность <math>k</math>

'''Вычисляемые данные:''' Ортонормированный базис <math>\{v_1, v_2, \dots, v_k\}</math> подпространства <math>K_k(A, v_1)</math>

Формулы метода:
:<math>
\begin{align}
&\omega = Av_j \\
&h_{ij} = (\omega, v_i) \\
&\omega = \omega - h_{ij}v_i \\
&h_{(i+1)j} = \|\omega\| \\
&v_{j+1} = \frac{\omega}{h_{(i+1)j}} \\
&j = \overline{1,k}, \ i = \overline{1,j}
\end{align}
</math>
В результате выполнения процесса Арнольди получаем:
:<math>V_k =\{v_1, v_2, \dots, v_k\}</math> - ортонормированный базис подпространства Крылова
:<math>\overline{V_k} = \{v_1, v_2, \dots, v_k, v_{k+1}\}</math> - матрица, расширенная последним вычисленным вектором <math>v_{k+1}</math>
:<math>H_k</math> - верхняя Хессенбергова матрица, элементы которой равны коэффициентам ортогонализации:
:<math>H_k =
\begin{pmatrix}
h_{11} & h_{12} & h_{13} & h_{14} & \dots & h_{1k} \\
h_{21} & h_{22} & h_{23} & h_{24} & \dots & h_{2k} \\
0 & h_{32} & h_{33} & h_{34} & \dots & h_{3k} \\
\vdots & &\ddots & \ddots & & \vdots \\
0 & \dots & 0 & h_{k-1,k-2}& h_{k-1, k-1} & h_{k-1, k} \\
0 & \dots & 0 & 0 & h_{k, k-1} & h_{k, k} \\
0 & \dots & & & 0& h_{k+1, k}
\end{pmatrix}
</math>

==== Минимизация нормы невязки ====
Выполнив несложные преобразования можно получить выражение для невязки на <math>k</math>- й итерации:
:<math>
r_k = \beta e_1 - H_ky_k
</math>
Очевидно, что для задачи
:<math>
\|r_k{\|}_2 \to \min
</math>
минимум достигается при
:<math> H_ky_k = \beta e_1 </math>
Для решения последней системы матрица <math>H_k</math> приводится к верхнему треугольному виду с помощью <math> k </math> вращений Гивенса:
:<math> R_k = \Omega_k\Omega_{k-1}\dots \Omega_1 </math>,
:<math> \Omega_i = \begin{pmatrix} 1 & &&&&&& \\
&\ddots &&&&&&\\
&&1&&&&& \\
&&&c_i&s_i &&& \\
&&&-s_i& c_i &&&\\
&&&&&1&&& \\
&&&&&&\ddots&\\
&&&&&&&1 \\ \end{pmatrix}, \quad
s_i = \frac{h_{i+1,i}}{\sqrt{h_{ii}^2+h_{i+1,i}^2}}, \quad c_i = \frac{h_{ii}}{\sqrt{h_{ii}^2+h_{i+1,i}^2}}</math>

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

=== Макроструктура алгоритма ===
В методе используются следующие макрооперции:
* Умножение матрицы на вектор
* Вычисление скалярного произведение двух векторов
* Нахождени <math>l_2</math>-нормы вектора
* Умножение матриц специальной структуры
* Решение системы уравнений с верхней треугольной матрицей

=== Схема реализации последовательного алгоритма ===
Для обобщенного метода мимнимальных невязок число векторов порядка <math>n</math>, которых необходимо хранить в памяти, растет линейно с ростом <math>k</math>, в то время как число умножений имеет квадратичную зависимость от числа итераций. Этот факт является мотивацией для того, чтобы использовать метод минимальных невязок с рестартами. Вместо того, чтобы формировать базис размерности <math>k</math>, выбирается параметр <math>m << n </math> и с помощью ортонормированного базиса размерности <math>m</math> строится приближенное решение. Посредством такой схемы необходимое количество памяти может быть оценено заранее и оставаться внутри определенных пределов. Приведем подробное описание алгоритма GMRES c рестартами:

1. <math>k = 0 </math>; инициализировать <math>x_0</math>; <math>r_0=b-Ax_0</math> и <math>v_1=\frac{r_0}{\|r_0 \|}</math>

2. Выполнить <math>m</math> шагов процессса Арнольди:

Для <math> j = \overline{1,m} </math> выполнять:
<math>
\omega = Av_j
</math>
Для <math> i = \overline{1,j} </math> выполнять:
<math>
\begin{align}
&h_{ij} = (\omega, v_i) \\
&\omega = \omega - h_{ij}v_i \\
\end{align}
</math>
<math>
\begin{align}
h_{(i+1)j} = \|\omega\| \\
v_{j+1} = \frac{\omega}{h_{(i+1)j}} \\
\end{align}
</math>

3. Вычислить <math>y_m=\arg\min_{y} \| \beta e_1 - H_m y \|,\ y \in \R^m</math> и <math>x_m=x_0+V_my_m</math>

4. Вычислить <math>r_m=b-Ax_m</math>. Если требуемая точность достигнута, остановиться

5. Рестарт:
<math>x_0 = x_m</math>
<math>r_m = \frac{r_m}{\|r_m\|}</math>
Перейти к шагу 2.

=== Последовательная сложность алгоритма ===
Вычислительная сложность метода GMRES складывается из сложности решения задачи минимизации невязки и сложности процесса Арнольди. Так как в
задаче минимизации невязки матрица системы имеет размер <math>m+1 \times m</math>, для нахождения решения требуется <math>O(m^2)</math> операций. Процесс
Арнольди предполагает выполнение <math>O(mn)</math> операций плюс <math>O(n^2)</math> операций для умножений матрицы на вектор.

=== Информационный граф ===
Основным ресурсом параллелизма будут являться умножение матрицы на вектор<ref>https://algowiki-project.org/ru/Умножение_плотной_неособенной_матрицы_на_вектор_(последовательный_вещественный_вариант)</ref> и вычисление скалярных произведений<ref>https://algowiki-project.org/ru/Скалярное_произведение_векторов,_вещественная_версия,_последовательно-параллельный_вариант</ref>. Представим информационные графы для данных алгоритмов:

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: (700 + 15) + 3 * (3 - 1) + 8}}px">
<gallery widths=600px heights=600px>
File:Matvec.png|Рисунок 1. Граф последовательного умножения плотной матрицы на вектор с отображением входных и выходных данных
File:Dot.png|Рисунок 2. Последовательно-параллельное вычисление скалярного произведения
</gallery>
<div class="thumbcaption" style="text-align:center">
</div>
</div>
</div>
</center>

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

Для '''умножения квадратной матрицы на вектор''' порядка <math>n</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n</math> операций).

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

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n</math> операций).

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

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

Для '''вычисления скалярного произведения векторов размерности <math>n</math>''' параллельном варианте требуется последовательно выполнить следующие ярусы:
* 1 ярус вычисления произведений,
* <math>k - 1</math> ярусов суммирования по частям массивов (<math>p</math> ветвей),
* <math>p - 1</math> ярусов суммирования (одна последовательная ветвь),
где <math>p</math> - количество процессоров, <math>k</math>- номер процессора.

Таким образом, в параллельном варианте критический путь алгоритма (и соответствующая ему высота ЯПФ) будет зависеть от произведённого разбиения массива на части. В оптимальном случае (<math>p = \sqrt{n}</math>) высота ЯПФ будет равна <math> 2 \sqrt{n} - 1</math>. При классификации по высоте ЯПФ, таким образом, последовательно-параллельный метод относится к алгоритмам ''со сложностью «корень квадратный»''. При классификации по ширине ЯПФ его сложность также будет ''«корень квадратный»''.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' Матрица <math>A \in R^{n\times n}</math>, вектор <math>b \in R^n</math>, точность <math>\varepsilon</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m \in R^n</math>. Объём: <math>n</math>

=== Свойства алгоритма ===
В точной арифметике GMRES всегда сходится не более чем за <math>n </math> итераций (т.к. <math>K_n = R^n = Im(A)</math>). При этом последовательность решений сходится монотонно, в связи с тем, что <math>\|r_{m+1}\| \le \|r_m\|</math>. Этот факт справедлив из-за того, что подпространства, по которым минимизируется <math>\|r_m\|</math>, вложены друг в друга: <math>K_m \subset K_{m+1}</math>. Таким образом, минимизация по подпрастранствам большей размерности приведет нас к меньшей норме невязки.

Скорость сходимости метода зависит от расположения собственных значений матрицы <math>A</math> на комплексной плоскости. Для быстрой сходимости, собственные значения должны быть сконцентрированны на достаточном расстоянии от начала координат. Заметим, что расположение собственных чисел намного важнее, чем число обусловленности матрицы <math>A</math>, являющимся главным критерием быстрой сходимости для метода сопряженных градиентов.

Если обобщенный метод минимальных невязок применяется к СЛАУ с матрицами, обладающими "хорошим" распределением собственных чисел, то он может работать быстрее чем стандартное <math>LU</math> разложение даже в том случае, если матрица плотна и неструктурированна.

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

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

=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Реализации обобщенного метода минимальных невязок (GMRES) присутствуют во многих пакетах. Приведем некоторые из них:
* [http://www.netlib.org/linpack/ LINPACK]
* [http://math.nist.gov/tnt/download.html/ JAMA/C++]
* [http://math-atlas.sourceforge.net/ ATLAS]
* [http://software.intel.com/mkl‎/ Intel MLK]
* [http://math.nist.gov/iml++/ IML++]
* [http://netlib.org/lapack/ LAPACK]
* [http://osl.iu.edu/research/mtl/ MTL]
* [http://www-users.cs.umn.edu/~saad/software/SPARSKIT/ SPARSKIT]
* [http://researcher.watson.ibm.com/researcher/view_group.php?id=1426 WSMP]
* [https://www.mcs.anl.gov/petsc/ PETSC]
* [https://www.scipy.org// SciPy]
* [https://www.mathworks.com/ Matlab]
* [https://fenicsproject.org/ FEniCS Project]

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

[1] A parallel implementation of the restarted GMRES iterative algorithm for nonsymmetric systems of linear equations, Rudnei Dias da Cunha, Centro de Processamento de Dados, Universidade Federal do Rio Grande do Sul, Brazil and Computing Laboratory, University of Kent, Canterbury, UK and Tim Hopkins, Computing Laboratory, University of Kent, Canterbury, UK, 1993
[2] Gene H. Golub, Charles F. Van Loan, Matrix and Computations, 4th edition

Участница:Эльвира Ахиярова/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-16T18:16:34Z

Lineprinter:

{{Assignment}}
Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок).

{{algorithm
| name = Обобщеннный метод минимальных невязок
| serial_complexity = <math>O(mn+m^2+n^2)</math>
| input_data = <math>n^2+n+1</math>
| output_data = <math>n</math>
}}
Основные авторы описания: [[Участник:Эльвира Ахиярова|Э.А.Ахиярова]]

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

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

Обобщенный метод минимальных невязок (GMRES) - это итерационный метод для нахождения приближенного решения системы линейных алгебраических уравнений <math>Ax = b </math> с произвольной матрицей <math>A</math>. Алгоритм был преложен в 1986 году Йозефом Саадом и Мартином Г. Шульцем
<ref>Y. Saad and M.H. Schultz, "GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems", SIAM J. Sci. Stat. Comput., 7:856-869, 1986. doi:10.1137/0907058.</ref>.

В то время как применение классических итерационных алгоритмов для решения СЛАУ ограничивается либо диагональным преобладанием, либо положительной определенностью матрицы, GMRES может быть использован для систем с произвольной невырожденной матрицей <math>A</math>. Данный метод опирается на итерации Арнольди для нахождения минимизирующего невязку вектора из подпространства Крылова <ref>https://en.wikipedia.org/wiki/Krylov_subspace</ref>.

Основным недостатком метода GMRES является поитерационное увеличение объема требуемой памяти. В связи с этим, для некоторых вычислительных систем выполенние программы метода может быть невозможным. Для некоторых систем используют модифицированный обобщенный метод минимальных невязок - GMRES(m), который подразумевает использование рестартов, существенно сокращающих объемы необходимой памяти.

Ключевая идея обобщенного метода минимальных невязок основана на решении задачи наименьших квадратов на каждом итерационном шаге. На каждом <math>k</math>-м шаге точное решение <math>x^* = A^{-1}b </math> аппроксимируется вектором <math>x_k \in K_k</math>, таким образом, что:
:<math>
\|r_k{\|}_2 = \|Ax_k-b{\|}_2 \to \min
</math>,
где <math>K_k</math> - подпространство Крылова <math> k </math> - го порядка.

=== Математическое описание алгоритма ===
'''Исходные данные:''' Матрица <math>A \in R^{n\times n}</math>, вектор правой части <math>b \in R^n</math>.

'''Вычисляемые данные:''' Приближенное решение <math>\tilde{x} \in R^n</math> системы <math>Ax = b</math>.

На каждом <math>k</math>-м шаге метода решение <math>x_k</math> рассматривается в виде <math>x_0+Vy_k</math>, где столбцы <math>v_k</math> матрицы <math>V</math> находятся с помощью процесса Арнольди для построения ортонормированного базиса <math>\{v_1, v_2, \dots, v_k\}</math> подпространства Крылова <math>K_k(A, v_1)</math>,
вектор <math>y_k</math> представляет собой решение системы <math>H_ky_k = \beta_k e_1</math>, где <math>H_k</math> - верхняя матрица Хессенберга<ref>https://en.wikipedia.org/wiki/Hessenberg_matrix</ref> размера <math>k\times k</math>, элементы которой формируются в процессе ортогонализации Арнольди, <math>\beta_k = \|r_0{\|}_2, \ r_0 = b - Ax_0 </math>, и, наконец, <math>e_1</math> - канонический вектор <math>{\begin{pmatrix}1&0&\dots 0\end{pmatrix}}^T</math> размерности <math>k</math>

Рассмотрим подробнее процесс ортогонализации Арнольди:

==== Процесс Арнольди ====
'''Исходные данные:''' начальный ортонормированный вектор <math>v_1</math> и размерность <math>k</math>

'''Вычисляемые данные:''' Ортонормированный базис <math>\{v_1, v_2, \dots, v_k\}</math> подпространства <math>K_k(A, v_1)</math>

Формулы метода:
:<math>
\begin{align}
&\omega = Av_j \\
&h_{ij} = (\omega, v_i) \\
&\omega = \omega - h_{ij}v_i \\
&h_{(i+1)j} = \|\omega\| \\
&v_{j+1} = \frac{\omega}{h_{(i+1)j}} \\
&j = \overline{1,k}, \ i = \overline{1,j}
\end{align}
</math>
В результате выполнения процесса Арнольди получаем:
:<math>V_k =\{v_1, v_2, \dots, v_k\}</math> - ортонормированный базис подпространства Крылова
:<math>\overline{V_k} = \{v_1, v_2, \dots, v_k, v_{k+1}\}</math> - матрица, расширенная последним вычисленным вектором <math>v_{k+1}</math>
:<math>H_k</math> - верхняя Хессенбергова матрица, элементы которой равны коэффициентам ортогонализации:
:<math>H_k =
\begin{pmatrix}
h_{11} & h_{12} & h_{13} & h_{14} & \dots & h_{1k} \\
h_{21} & h_{22} & h_{23} & h_{24} & \dots & h_{2k} \\
0 & h_{32} & h_{33} & h_{34} & \dots & h_{3k} \\
\vdots & &\ddots & \ddots & & \vdots \\
0 & \dots & 0 & h_{k-1,k-2}& h_{k-1, k-1} & h_{k-1, k} \\
0 & \dots & 0 & 0 & h_{k, k-1} & h_{k, k} \\
0 & \dots & & & 0& h_{k+1, k}
\end{pmatrix}
</math>

==== Минимизация нормы невязки ====
Выполнив несложные преобразования можно получить выражение для невязки на <math>k</math>- й итерации:
:<math>
r_k = \beta e_1 - H_ky_k
</math>
Очевидно, что для задачи
:<math>
\|r_k{\|}_2 \to \min
</math>
минимум достигается при
:<math> H_ky_k = \beta e_1 </math>
Для решения последней системы матрица <math>H_k</math> приводится к верхнему треугольному виду с помощью <math> k </math> вращений Гивенса:
:<math> R_k = \Omega_k\Omega_{k-1}\dots \Omega_1 </math>,
:<math> \Omega_i = \begin{pmatrix} 1 & &&&&&& \\
&\ddots &&&&&&\\
&&1&&&&& \\
&&&c_i&s_i &&& \\
&&&-s_i& c_i &&&\\
&&&&&1&&& \\
&&&&&&\ddots&\\
&&&&&&&1 \\ \end{pmatrix}, \quad
s_i = \frac{h_{i+1,i}}{\sqrt{h_{ii}^2+h_{i+1,i}^2}}, \quad c_i = \frac{h_{ii}}{\sqrt{h_{ii}^2+h_{i+1,i}^2}}</math>

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

=== Макроструктура алгоритма ===
В методе используются следующие макрооперции:
* Умножение матрицы на вектор
* Вычисление скалярного произведение двух векторов
* Нахождени <math>l_2</math>-нормы вектора
* Умножение матриц специальной структуры
* Решение системы уравнений с верхней треугольной матрицей

=== Схема реализации последовательного алгоритма ===
Для обобщенного метода мимнимальных невязок число векторов порядка <math>n</math>, которых необходимо хранить в памяти, растет линейно с ростом <math>k</math>, в то время как число умножений имеет квадратичную зависимость от числа итераций. Этот факт является мотивацией для того, чтобы использовать метод минимальных невязок с рестартами. Вместо того, чтобы формировать базис размерности <math>k</math>, выбирается параметр <math>m << n </math> и с помощью ортонормированного базиса размерности <math>m</math> строится приближенное решение. Посредством такой схемы необходимое количество памяти может быть оценено заранее и оставаться внутри определенных пределов. Приведем подробное описание алгоритма GMRES c рестартами:

1. <math>k = 0 </math>; инициализировать <math>x_0</math>; <math>r_0=b-Ax_0</math> и <math>v_1=\frac{r_0}{\|r_0 \|}</math>

2. Выполнить <math>m</math> шагов процессса Арнольди:

Для <math> j = \overline{1,m} </math> выполнять:
<math>
\omega = Av_j
</math>
Для <math> i = \overline{1,j} </math> выполнять:
<math>
\begin{align}
&h_{ij} = (\omega, v_i) \\
&\omega = \omega - h_{ij}v_i \\
\end{align}
</math>
<math>
\begin{align}
h_{(i+1)j} = \|\omega\| \\
v_{j+1} = \frac{\omega}{h_{(i+1)j}} \\
\end{align}
</math>

3. Вычислить <math>y_m=\arg\min_{y} \| \beta e_1 - H_m y \|,\ y \in \R^m</math> и <math>x_m=x_0+V_my_m</math>

4. Вычислить <math>r_m=b-Ax_m</math>. Если требуемая точность достигнута, остановиться

5. Рестарт:
<math>x_0 = x_m</math>
<math>r_m = \frac{r_m}{\|r_m\|}</math>
Перейти к шагу 2.

=== Последовательная сложность алгоритма ===
Вычислительная сложность метода GMRES складывается из сложности решения задачи минимизации невязки и сложности процесса Арнольди. Так как в
задаче минимизации невязки матрица системы имеет размер <math>m+1 \times m</math>, для нахождения решения требуется <math>O(m^2)</math> операций. Процесс
Арнольди предполагает выполнение <math>O(mn)</math> операций плюс <math>O(n^2)</math> операций для умножений матрицы на вектор.

=== Информационный граф ===
Основным ресурсом параллелизма будут являться умножение матрицы на вектор<ref>https://algowiki-project.org/ru/Умножение_плотной_неособенной_матрицы_на_вектор_(последовательный_вещественный_вариант)</ref> и вычисление скалярных произведений<ref>https://algowiki-project.org/ru/Скалярное_произведение_векторов,_вещественная_версия,_последовательно-параллельный_вариант</ref>. Представим информационные графы для данных алгоритмов:

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: (700 + 15) + 3 * (3 - 1) + 8}}px">
<gallery widths=600px heights=600px>
File:Matvec.png|Рисунок 1. Граф последовательного умножения плотной матрицы на вектор с отображением входных и выходных данных
File:Dot.png|Рисунок 2. Последовательно-параллельное вычисление скалярного произведения
</gallery>
<div class="thumbcaption" style="text-align:center">
</div>
</div>
</div>
</center>

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

Для '''умножения квадратной матрицы на вектор''' порядка <math>n</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n</math> операций).

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

* по <math>n</math> ярусов умножений и сложений (в каждом из ярусов — <math>n</math> операций).

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

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

Для '''вычисления скалярного произведения векторов размерности <math>n</math>''' параллельном варианте требуется последовательно выполнить следующие ярусы:
* 1 ярус вычисления произведений,
* <math>k - 1</math> ярусов суммирования по частям массивов (<math>p</math> ветвей),
* <math>p - 1</math> ярусов суммирования (одна последовательная ветвь),
где <math>p</math> - количество процессоров, <math>k</math>- номер процессора.

Таким образом, в параллельном варианте критический путь алгоритма (и соответствующая ему высота ЯПФ) будет зависеть от произведённого разбиения массива на части. В оптимальном случае (<math>p = \sqrt{n}</math>) высота ЯПФ будет равна <math> 2 \sqrt{n} - 1</math>. При классификации по высоте ЯПФ, таким образом, последовательно-параллельный метод относится к алгоритмам ''со сложностью «корень квадратный»''. При классификации по ширине ЯПФ его сложность также будет ''«корень квадратный»''.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' Матрица <math>A \in R^{n\times n}</math>, вектор <math>b \in R^n</math>, точность <math>\varepsilon</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m \in R^n</math>. Объём: <math>n</math>

=== Свойства алгоритма ===
В точной арифметике GMRES всегда сходится не более чем за <math>n </math> итераций (т.к. <math>K_n = R^n = Im(A)</math>). При этом последовательность решений сходится монотонно, в связи с тем, что <math>\|r_{m+1}\| \le \|r_m\|</math>. Этот факт справедлив из-за того, что подпространства, по которым минимизируется <math>\|r_m\|</math>, вложены друг в друга: <math>K_m \subset K_{m+1}</math>. Таким образом, минимизация по подпрастранствам большей размерности приведет нас к меньшей норме невязки.

Скорость сходимости метода зависит от расположения собственных значений матрицы <math>A</math> на комплексной плоскости. Для быстрой сходимости, собственные значения должны быть сконцентрированны на достаточном расстоянии от начала координат. Заметим, что расположение собственных чисел намного важнее, чем число обусловленности матрицы <math>A</math>, являющимся главным критерием быстрой сходимости для метода сопряженных градиентов.

Если обобщенный метод минимальных невязок применяется к СЛАУ с матрицами, обладающими "хорошим" распределением собственных чисел, то он может работать быстрее чем стандартное <math>LU</math> разложение даже в том случае, если матрица плотна и неструктурированна.

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

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

=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Реализации обобщенного метода минимальных невязок (GMRES) присутствуют во многих пакетах. Приведем некоторые из них:
* [http://www.netlib.org/linpack/ LINPACK]
* [http://math.nist.gov/tnt/download.html/ JAMA/C++]
* [http://math-atlas.sourceforge.net/ ATLAS]
* [http://software.intel.com/mkl‎/ Intel MLK]
* [http://math.nist.gov/iml++/ IML++]
* [http://netlib.org/lapack/ LAPACK]
* [http://osl.iu.edu/research/mtl/ MTL]
* [http://www-users.cs.umn.edu/~saad/software/SPARSKIT/ SPARSKIT]
* [http://researcher.watson.ibm.com/researcher/view_group.php?id=1426 WSMP]
* [https://www.mcs.anl.gov/petsc/ PETSC]
* [https://www.scipy.org// SciPy]
* [https://www.mathworks.com/ Matlab]
* [https://fenicsproject.org/ FEniCS Project]

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

[1] A parallel implementation of the restarted GMRES iterative algorithm for nonsymmetric systems of linear equations, Rudnei Dias da Cunha, Centro de Processamento de Dados, Universidade Federal do Rio Grande do Sul, Brazil and Computing Laboratory, University of Kent, Canterbury, UK and Tim Hopkins, Computing Laboratory, University of Kent, Canterbury, UK, 1993
[2] Gene H. Golub, Charles F. Van Loan, Matrix and Computations, 4th edition

Участник:AleksLevin/Алгоритм Ланцоша вычисления собственных значений симметричной матрицы для точной арифметики (без переортогонализации)

2016-11-16T18:16:06Z

Lineprinter: Lineprinter переименовал страницу [[Алгоритм Ланцоша вычисления собственных значений симметричной матрицы для точной арифметики (без переорт…

Основные авторы описания: Левин А.Д. (студент, кафедра вычислительных методов, 604 группа) - все описанные разделы самостоятельно

{{algorithm
| name = Алгоритм Ланцоша для точной арифметики (без переортогонализации)
| serial_complexity = <math>O(k\,n^2)</math>
| pf_height = <math>O(\log_2 n)</math> для каждой итерации алгоритма. Максимальное число таких итераций = <math>k</math>, если не будет осуществлён ранний выход из цикла.
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n^2+3n}{2} + 1</math>
| output_data = <math>k\;(n + 1)</math>
}}

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

== Общее описание алгоритма ==
Данный алгоритм появился в 1950 г. и носит имя венгерского физика и математика Корнелия Ланцоша (венг. Lánczos Kornél). Алгоритм Ланцоша относится к итерационным методам вычисления собственных значений для матриц столь больших порядков <math style="vertical-align:0%;> n</math>, что к ним нельзя применить прямые методы из-за ограничений по времени и памяти.

Сам Ланцош указывал, что его метод предназначен для отыскания нескольких собственных векторов симметричных матриц, хотя к методу сразу было обращено внимание, как к способу приведения всей матрицы к трёхдиагональному виду. Двадцатью годами позже канадский математик Крис Пэж показал, что, несмотря на чувствительность к округлениям, алгоритм Ланцоша - эффективное средство вычисления некоторых <math style="vertical-align:0%;>k</math> собственных чисел и соответствующих им собственных векторов <span style="color:#4169E1">[1, c.276]</span>.
Обычно число <math style="vertical-align:0%;>k</math> берут в два раза больше, чем количество собственных значений матрицы, которые поставлена цель найти, и оно имеет порядок не более <math style="vertical-align:-10%;>10^2</math><ref>Susan W. Bostic - Lanczos Eigensolution Method for High-Perfomance Computers, page 7</ref>

Алгоритм Ланцоша для вычисления собственных значений симметричной матрицы <math style="vertical-align:0%;>A</math> соединяет в себе метод Ланцоша для построения последовательности подпространств Крылова и ортонормированных векторов Ланцоша и процедуру Рэлея-Ритца получения оптимальных приближений собственных значений и соответствующих собственных векторов исходной матрицы <math style="vertical-align:0%;>A</math> <span style="color:#4169E1">[2, с.381]</span>.

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

== Математическое описание алгоритма ==
Для лучшего понимания описания, данного в этом пункте статьи, рекомендуется ознакомиться с параграфом ''6.6 Методы Крыловского подпространства'' <span style="color:#4169E1">[2, с.313]</span>.
Здесь же дано краткое описание всех переменных, математических операций и необходимый теоретический минимум.

Алгоритм Ланцоша для вычисления <math style="vertical-align:0%;>k</math> собственных значений и собственных векторов вещественной симметричной матрицы <math style="vertical-align:0%;>A=A^T</math> в точной арифметике <span style="color:#4169E1">[2, с.381]</span>:

<math>
\begin{align}
q_1 = & \,\frac{b}{\|b\|_2},\; \beta_0 = 0,\; q_0 = 0\\
for \; & j = 1 \; to \; k \\
& z = A\,q_j\\
& \alpha_j = q^T_j z\\
& z = z - \alpha_j q_j - \beta_{j-1}q_{j-1}\\
& \beta_j = \|z\|_2\\
& If \; (\beta_j == 0) \; then\; stop\; the\; algorithm \\
& \; q_{j+1} = \frac{z}{\beta_j} \\
& compute\; eigenvalues\; and \;eigenvectors\;of \;matrix \;\;T_j= Q^T_j A Q\;\;and\;estimate \;the\; errors\\
end \; & for
\end{align}
</math>

В продемонстрированном выше алгоритме <math style="vertical-align:0%;>b</math> - заданный вещественный вектор. Также полагается известным алгоритм вычисления произведения матрицы <math style="vertical-align:0%;>A</math> на вектор <math style="vertical-align:0%;>x</math>.
Введём матрицу Крылова, определяемую следующим соотношением: <math>K_j = [b,Ab,A^2b,...,A^{j-1}b]</math>.

Далее, на практике, матрица <math style="vertical-align:0%;>K</math> заменяется матрицей <math style="vertical-align:-20%;>Q</math>, такой, что при любом числе <math style="vertical-align:0%;>k</math> линейные оболочки первых <math style="vertical-align:0%;>k</math> столбцов в <math style="vertical-align:0%;>K</math> и <math style="vertical-align:-20%;>Q</math> являются одним и тем же подпространством <span style="color:#4169E1">[2, c.315]</span>.
Тогда матрица <math style="vertical-align:-20%;>Q</math>, в отличие от матрицы <math style="vertical-align:0%;>K</math>, хорошо обусловлена и легко обратима. В результате получаем матрицу <math>Q_j = [q_1, q_2, \dots, q_j]</math> размерности <math>n\times j</math>, столбцы которой ортогональны, являются базисом подпространства Крылова и называются векторами Ланцоша.

В алгоритме Ланцоша вычислению подлежит столько первых столбцов в матрице <math style="vertical-align:-20%;>Q_j</math>, сколько необходимо для получения требуемого приближения к решению <math>A\,x\,=b\,\,(A\,x=\lambda \, x)</math>.

Получение нулевого <math>\beta_j</math> в итерационном процессе - событие, желательное в том смысле, что оно свидетельствует о том, что найдено некоторое подпространство, являющееся в точности инвариантным, а все собственные значения матрицы <math style="vertical-align:-20%;>T_j</math> являются собственными значениями матрицы <math style="vertical-align:0%;>A</math>. На практике же нулевое и близкие к нулю значения получаются редко <span style="color:#4169E1">[3, стр. 429]</span>.

Затем на каждом шаге цикла формируется симметричная трёхдиагональная матрица <math>T_j = Q^T_j A Q</math>, к которой применяется процесс Рэлея-Ритца для поиска её собственных значений (на практике для поиска этих собственных значений можно использовать любой из специальных методов, изложенных в <span style="color:#4169E1">[3, <math>\S</math> 8.4]</span>).
Эти собственные значения, они же числа Ритца, и полагаются приближёнными собственными значениями исходной матрицы <math style="vertical-align:0%;>A</math>.

Если требуется вычислить собственные векторы, то необходимо хранить вычисляемые векторы Ланцоша. Если работа при этом производится только с оперативной памятью, то при большом порядке исходной матрицы (а именно для таких матриц и предназначен метод Ланцоша) число шагов <math style="vertical-align:-10%;>j</math>, которые могут быть выполнены до того момента, как оперативная память будет исчерпана, будет очень незначительно, а следовательно, искомые собственные пары могут не успеть сойтись с требуемой точностью. В этом случае метод Ланцоша можно использовать итерационным образом: после выполнения заданного числа шагов процесс прерывается и, если еще не все требуемые пары Ритца сошлись с требуемой точностью, то формируется новый начальный вектор <math style="vertical-align:-20%;>q_1</math>, являющийся линейной комбинацией векторов Ритца, еще не сошедшихся с заданной точностью, и процесс начинается заново.<ref>http://num-anal.srcc.msu.ru/lib_na/int_ae/int_ae6.htm (пункт 6.5)</ref>

== Вычислительное ядро алгоритма ==
Вычислительное ядро рассматриваемого алгоритма (наиболее ресурсно-затратная часть алгоритма) - формирование на каждом шаге цикла промежуточного вектора <math>z</math>, вычисляемого по формуле: <math>z = A\,q_j</math>

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

В первой части алгоритма, где итерационно строятся Крыловское подпространство и трёхдиагональная матрица <math style="vertical-align:-30%;>T_j</math>, можно выделить следующие макрооперации:
* умножение матрицы на вектор (в свою очередь представляет собой умножение вектора на число и сложение векторов);
* вычисление нормы (скалярное произведение векторов + вычисление квадратного корня);
* скалярное произведение векторов;
* сложение векторов и их умножение на вещественные числа

Умножение матрицы на вектор - весьма дешевая и нетривиальная операция, если предполагать, что исходная матрица <math style="vertical-align:0%;>A</math> разреженная. Именно она подлежит оптимизации с использованием техник распараллеливания, поскольку она является вычислительным ядром алгоритма, а весь упомянутый процесс построения матрицы <math style="vertical-align:-30%;>T_j</math> выполняется последовательно.

Вторая часть алгоритма - поиск собственных значений матрицы <math style="vertical-align:-30%;>T_j</math>, в нашем случае с помощью процедуры Рэлея-Ритца, может рассматриваться как отдельная нетривиальная макрооперация.

== Схема реализации последовательного алгоритма ==
С целью полностью не дублировать пункт <math style="vertical-align:0%;>\mathbf{1.2}</math> данной статьи, где представлен очень наглядный и доступный для понимания псевдокод алгоритма, постараемся лишь коротко просуммировать и обобщить весь перечень последовательных действий в рассматриваемом алгоритме.

В качестве входных данных имеем: вещественная симметричная матрица <math style="vertical-align:0%;>A</math> размера <math style="vertical-align:-10%>n\times n</math>, известный вещественный вектор <math style="vertical-align:0%;>b</math> длины <math style="vertical-align:0%>n</math> и число <math style="vertical-align:0%>k<n</math>.

Далее:
* Инициализируем вещественную константу <math style="vertical-align:-20%;>\beta_0</math> и векторы <math style="vertical-align:-10%;>q_0</math> и <math style="vertical-align:-10%;>q_1</math>
* Итерационно для всех <math style="vertical-align:-20%>j=\overline {1,k}</math>:
** Вычисляем вспомогательный вектор <math style="vertical-align:0%>z</math>, используя умножение матрицы на вектор
** Вычисляем, используя скалярное произведение векторов, значение <math style="vertical-align:-30%>\alpha_j</math> - элемент на главной диагонали трёхдиагональной матрицы <math style="vertical-align:-30%;>T_j</math>
** Вычисляем по формуле новое значение и перезаписываем вектор <math style="vertical-align:0%>z</math>
** Вычисляем значение <math style="vertical-align:-20%>\beta_j</math> - элементы непосредственно над и под главной диагональю той же матрицы <math style="vertical-align:-30%;>T_j</math>
** Вычисляем с вектора <math style="vertical-align:0%>z</math> очередной столбец матрицы <math style="vertical-align:-20%>Q</math>, он же вектор Ланцоша : <math style="vertical-align:-20%>\,\,q_{j+1}</math>
** Теперь, когда матрица <math style="vertical-align:-30%;>T_j</math> сформирована на очередном шаге, находим её собственные значения и вектора, например с помощью процедуры Рэлея-Ритца (о используемых на практике методах нахождения подробнее было сказано ранее в математическом описании алгоритма)
** Переходим на следующую итерацию: <math style="vertical-align:-20%>j</math>++

== Последовательная сложность алгоритма ==
Оценим количество операций и сложность последовательного алгоритма, изложенного в предыдущем пункте.
*Для вычисления вектора <math style="vertical-align:0%>z</math> умножается матрица размера <math style="vertical-align:-10%>n\times n</math> на вектор длины <math style="vertical-align:0%>n</math>, и потребуется <math style="vertical-align:0%>n^2</math> операций умножения и <math style="vertical-align:0%>n^2</math> операций сложения.
*Умножение векторов <math style="vertical-align:-20%>q^T_j</math> и <math style="vertical-align:0%>z</math> длины <math style="vertical-align:0%>n</math> потребует <math style="vertical-align:0%>n</math> операций умножения и <math style="vertical-align:0%>n</math> операций сложения.
*При вычислении нового значения вектора <math style="vertical-align:0%>z</math> поэлементное сложение двух векторов длины <math style="vertical-align:0%>n</math> требует <math style="vertical-align:0%>n</math> операций сложения.
*Умножение вектора длины <math>n</math> на вещественное число требует <math style="vertical-align:0%>n</math> операций умножения.
*Нахождение квадратичной нормы вектора <math style="vertical-align:0%>z</math> длины <math style="vertical-align:0%>n</math> требует <math style="vertical-align:0%>n</math> умножений и <math style="vertical-align:0%>n</math> сложений и ещё 1 операцию извлечения квадратного корня.
*Заключительное нахождение собственных значений и собственных векторов трёхдиагональной матрицы <math style="vertical-align:-30%>T_j</math> размера <math style="vertical-align:-20%>j\times j</math> с помощью QR-алгоритма потребует в худшем случае <math style="vertical-align:-30%>O(j^3)</math> операций.<ref>http://num-anal.srcc.msu.ru/lib_na/int_ae/int_ae6.htm (пункт 6.2)</ref>

Посчитаем теперь суммарное количество простейших операций на одной итерации алгоритма (без учёта записей в память):
*<math style="vertical-align:0%>n^2+5\,n</math> операций умножения/деления
*<math style="vertical-align:0%>n^2+4\,n</math> операций сложения/вычитания
*1 операция извлечения квадратного корня<br>
Отдельно после всех итераций при <math style="vertical-align:-20%>j=k</math> :
*<math style="vertical-align:-30%>O(k^3)</math> операций для поиска собственных значений и собственных векторов трёхдиагональной матрицы <math style="vertical-align:-30%>T_k</math>

Итого можно утверждать следующее:

Последовательная сложность одной итерации рассматриваемого алгоритма: <math style="vertical-align:-30%>O(n ^ 2) </math><br>
Суммарная сложность алгоритма (<math style="vertical-align:0%>k</math> итераций): <math style="vertical-align:-30%>O(k\,n ^ 2) + O(k ^ 3)</math> <ref>Здесь мы полагаем, что мы не вычисляем собственные значения и векторы матрицы <math style="vertical-align:-20%>T_j</math> на каждом промежуточном шаге, а лишь единожды затрачиваем <math style="vertical-align:-20%>O(k ^ 3)</math> действий в конце для нахождения <math style="vertical-align:0%>k</math> собственных значений и векторов матрицы <math style="vertical-align:-20%>T_k</math></ref> <br><br>
На практике же обычно рассматривается число <math style="vertical-align:0%>k<<n</math>, поэтому второе слагаемое можно опустить.

== Информационный граф ==
На рисунке продемонстрирован граф одной итерации (при каком-либо произвольном значении итератора <math style="vertical-align:-20%>j</math>) описанного алгоритма без отображения входных и выходных данных. Наглядно продемонстрированы связи между всеми действиями, и с помощью деления на <math style="vertical-align:0%>n</math> потоков показано, какие операции возможно выполнять параллельно на каждом шаге с целью оптимизации и экономии машинного времени. В результате, после параллельно выполненных операций '''Division''' на заключительном ярусе, на выходе имеем значение следующего вектора Ланцоша <math style="vertical-align:-20%>q_{j+1}</math>, после чего следует переход на следующую итерацию, и процесс повторяется.

[[Файл:Levin_graph.png|600px|thumb|center|'''Simp''' (от англ. simple) - операции сложения и умножения вещественных чисел при вычислении произведения матрицы на вектор;<br><br>
'''Vec mult''' (от англ. vectors multiplication) - операция скалярного умножения двух векторов;<br><br>
'''Vec subtr''' (от англ. vectors subtraction, из-за использованных в операции вычитаний векторов) - операция умножения вектора на число (выполняется дважды) и формирование нового значения <math style="vertical-align:0%>z_{new}</math> по формуле: <math style="vertical-align:-30%>z = z - \alpha_j q_j - \beta_{j-1}q_{j-1}</math><br><br>
<math>||\cdot||</math> - операция вычисления нормы вектора;<br><br>
'''Division''' - операция деления вектора на вещественное число <math style="vertical-align:-30%>\beta_j</math>]] <br>
Важно отметить, что упомянутые выше операции также легко поддаются оптимизации. Например, попарные умножения вещественных координат векторов при вычислении скалярного произведения также легко выполняются параллельно на <math style="vertical-align:0%>n</math> потоках, а затем можно применить суммирование методом сдваивания, о котором сказано в следующем пункте. Умножение или деление вектора на вещественное число являющееся, по определению, умножением или делением всех его координат на это число тоже может быть выполнено эффективнее, если мы используем <math style="vertical-align:0%>n</math> потоков, а не выполняем эти действия последовательно.

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

Умножение вещественной симметричной матрицы <math style="vertical-align:0%;>A</math> размера <math style="vertical-align:-10%>n\times n</math> на вектор <math style="vertical-align:0%;>b</math> длины <math style="vertical-align:0%>n</math> требует последовательного выполнения <math style="vertical-align:0%>n</math> ярусов умножений и сложений. Сложение элементов вектора длины <math style="vertical-align:0%>n</math> на каждом шаге перемножения можно оптимизировать и выполнить за <math style="vertical-align:-20%>\log_2 n</math> действий, если применять метод сдваивания.

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

Ресурс параллелизма алгоритма вычисления собственных значений построенной трёхдиагональной матрицы <math style="vertical-align:-20%>T_k</math> размера <math style="vertical-align:0%>k\times k</math> зависит от выбранного алгоритма (об этих алгоритмах подробнее было сказано в пункте '''1.2'''). Будет очень затратно с точки зрения объёма материала пытаться рассмотреть пусть даже часть этих методов в этой статье, а так же тонкости их распараллеливания. Предлагаем читателям при желании самим ознакомиться с этими алгоритмами на данном ресурсе или прибегнув к иным источникам.

При классификации по высоте ЯПФ, таким образом, алгоритм Ланцоша без переортогонализации относится к алгоритмам с ''логарифмической сложностью'', и его сложность равна <math style="vertical-align:-30%>O(\log_2 n)</math> с важным замечанием, что это сложность только одной итерации, а максимум в алгоритме может быть выполнено последовательно <math style="vertical-align:0%>k</math> таких однотипных итераций. <br>

Несмотря на то, что на графе в предыдущем пункте для лучшей визуализации и понимания было изображено <math style="vertical-align:0%>n</math> потоков (никаких допущений мы не делали и нарушений с точки зрения логики и математики нет, можно изобразить большее число потоков, просто часть времени некоторые из них могут бездействовать и не использоваться), на самом деле правильным и разумным будет реализовать начальное параллельное выполнение <math style="vertical-align:0%>n^2</math> операций умножения всех вещественных элементов матрицы <math style="vertical-align:0%>A</math> на соответствующие элементы вектора <math style="vertical-align:-30%>q_j</math>, после чего применять тот же самый упомянутый метод сдваивания. <br><br>
Поэтому при классификации по ширине ЯПФ его сложность будет ''квадратичной'' и равна <math style="vertical-align:-30%>O(n^2)</math>.

== Входные и выходные данные алгоритма ==
'''Входные данные алгоритма:''' вещественная симметричная <math style="vertical-align:0%;>A</math> размера <math style="vertical-align:-10%>n\times n</math>, вещественный вектор <math style="vertical-align:0%;>b</math> длины <math style="vertical-align:0%>n</math>, и одно целое число <math style="vertical-align:-10%>k</math>, означающее количество итераций.

'''Объём входных данных:''' <math style="vertical-align:-10%;>n^2 +n + 1 </math>. Если учесть, что матрица симметричная и достаточно для её однозначного определения задать элементы на главной диагонали и элементы над или под ней, то можно сократить объём входных данных с целью экономии памяти до: <math>\ \frac{n^2-n}{2}+n+n+1 =\frac{n^2+3n}{2} + 1</math>

'''Выходные данные алгоритма:''' вектор собственных значений <math style="vertical-align:0%;>\Theta^k</math> длины <math style="vertical-align:0%>k</math>, матрица <math style="vertical-align:0%>S^k</math> из соответствующих собственных векторов размера <math style="vertical-align:0%>n\times k</math>.

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

== Свойства алгоритма ==
В данном пункте перечислены без какой-либо хронологии или связи друг с другом наиболее важные и разнообразные свойства алгоритма, на которые стоит и полезно обратить внимание, а также которые выгодно отличают его от схожих алгоритмов, решающих ту же задачу.<br>
1) Отношение последовательной сложности алгоритма к параллельной,с учётом <math style="vertical-align:0%>k</math> итераций, равно <math>\frac{kn^2}{k \log_2{n}}=\frac{n^2}{\log_2{n}}</math>;<br>
2) Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, равна <math style="vertical-align:-70%>\frac{k\,n^2}{0.5\,n^2+1.5\,n+k\,n+k+1}</math> и <math style="vertical-align:-10%>\approx 2\,k</math>, так как на практике верно отношение <math style="vertical-align:0%>k<<n</math> ;<br><br>
3) Для собственных значений формируемых матриц <math style="vertical-align:-20%>T_j</math> верно отношение (следствие теоремы Коши о перемежаемости): <math style="vertical-align:-30%>\lambda_i(T_{k+1})\geq \lambda_i(T_{k})\geq \lambda_{i+1}(T_{k+1})\geq \lambda_{i+1}(T_{k})</math> ; <span style="color:#4169E1">[2, c.383]</span><br><br>
4) Крайние (наибольшие и наименьшие) собственные значения матриц <math style="vertical-align:-20%>T_j</math> сходятся к крайним собственным значениям матрицы <math style="vertical-align:0%>A</math> первыми (это часто происходит уже на ранних шагах при <math style="vertical-align:-20%>j\approx 2\,\sqrt{n}</math><ref>http://num-anal.srcc.msu.ru/lib_na/int_ae/int_ae6.htm (пункт 6.5)</ref>), а собственные значения в середине спектра - последними;<br><br>
5) Из-за ограниченной точности постепенно теряется ортогональность вектора Ланцоша <math style="vertical-align:-20%>q_j</math> к предыдущим векторам Ланцоша, поэтому необходимо примерно каждые 10-15 итераций проводить дорогостоящую операцию реортогонализации, но это уже будет иной алгоритм с очень малым различием в одной операции и в коде, реализующем его, соответственно; <ref>Sam Handler - The Lanczos Algorithm For Large-Scale Eigenvalue Problems (08.01.07), slide №8</ref><br><br>
6) Эффективность и быстрота выполнения алгоритма очень сильно зависит от скорости памяти (диска). Согласно тесту только ''6%'' времени работы программы приходится на вычисления, остальное время затрачивается на ожидание отклика диска;<ref>Sam Handler - The Lanczos Algorithm For Large-Scale Eigenvalue Problems (08.01.07), slide №10</ref><br><br>
7) Метод Ланцоша удобен тем, что не требует хранения исходной матрицы полным массивом: метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать разреженность матрицы или регулярность структуры матрицы. Поэтому метод Ланцоша может быть использован для матриц таких больших порядков, когда методы вращений и отражений не могут быть применены.

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

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

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

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

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

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

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

== Существующие реализации алгоритма ==
Несмотря на то, что алгоритм является далеко не самым популярным, алгоритмом, про который нельзя сказать, что он всегда «на слуху», на сегодняшний день существует множество реализаций на различных популярных языках.<br>
Перечислим далее некоторые из них, указывая язык программирования, лежащий в их основе, и некоторые важные характеристики, которые обсуждались в статье ранее:
*''Code on netlib.org by Jane Cullum and Ralph Willoughby'' ('''Fortran 77'''; без реортогонализации векторов; без реализации распараллеливания)<ref>http://www.netlib.org/lanczos/leval</ref>
*''Lanczos algorithm on freesourcecode.net'' ('''Matlab'''; присутствует реортогонализация векторов; без реализации распараллеливания)<ref>http://freesourcecode.net/matlabprojects/61741/lanczos-algorithm--in-matlab</ref>
*''Lanczos for eigenvalues in Numerical Linear Algebra, Spring 2007'' ('''Matlab'''; частичная или полная реортогонализация - доступны оба варианта; без реализации распараллеливания)<ref>Ссылки на файлы lanso.m и lanfu.m можно найти на https://www.nada.kth.se/~ruhe/2D5219/labs2007.html</ref>
*''Planso'' (название происходит от parallel Lanso.f) ''code by Kesheng Wu and Horst D. Simon'' ('''Fortran 77'''; частичная реортогонализация векторов; использование MPI для коммуникаций)<ref>https://github.com/jiahao/planso.jl/tree/master/external/PLAN/plan К сожалению, ссылка в описании пакета на github, ведущая на сайт National Energy Research Scientific Computing Center (NERSC), с более подробной информацией о данной программе больше не активна и выдаёт результат ''Page not found''</ref>
* ''Lanczos.cpp in the Vienna Computing Library'' ('''C++''', частичная реортогонализация, без реализации распараллеливания) <ref>http://viennacl.sourceforge.net/doc/lanczos_8cpp_source.html</ref>
* ''Parallel Eigen Values code using C++ AMP on microsoft msdn blog'' ('''C++'''; ?(нужно проанализировать код на наличие ортогонализации)? ; распараллеливание есть и реализовано через C++ AMP) <ref>https://blogs.msdn.microsoft.com/nativeconcurrency/2013/12/20/eigen-values/ Подробнее о C++ Accelerated Massive Parallelism можно почитать здесь: https://msdn.microsoft.com/ru-ru/library/hh265137(v=vs.140).aspx или здесь: http://professorweb.ru/my/csharp/optimization/level4/4_6.php </ref>

= Литература =
[1] Парлетт Б. - Симметричная проблема собственных значений. Численные методы //М.: Мир. - 1983. - С. 276-294

[2] James W. Demmel - Вычислительная линейная алгебра. Теория и приложения //Мир. - 2001. С. 381-391

[3] Голуб Дж., Ван Лоун Ч. - Матричные вычисления//М.: Мир. - 1999. - С. 426-436

[4] https://ru.wikipedia.org/wiki/Алгоритм_вычисления_собственных_значений#.D0.9C.D0.B0.D1.82.D1.80.D0.B8.D1.86.D1.8B_.D0.A5.D0.B5.D1.81.D1.81.D0.B5.D0.BD.D0.B1.D0.B5.D1.80.D0.B3.D0.B0_.D0.B8_.D1.82.D1.80.D1.91.D1.85.D0.B4.D0.B8.D0.B3.D0.BE.D0.BD.D0.B0.D0.BB.D1.8C.D0.BD.D1.8B.D0.B5_.D0.BC.D0.B0.D1.82.D1.80.D0.B8.D1.86.D1.8B

[5] http://num-anal.srcc.msu.ru/lib_na/int_ae/int_ae6.htm

[[en:Description of algorithm properties and structure]]

Участник:Davletshuna Alexandra/Метод Якоби вычисления сингулярных чисел и векторов

2016-11-09T00:09:46Z

Lineprinter: Lineprinter переименовал страницу Участник:Давлетшина Александра, Зайцева Александра/Метод Якоби вычисления сингулярных чисел и векторов…

{{Assignment|ASA}}

{{algorithm
| name = Метод Якоби вычисления сингулярных чисел и векторов
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n^2</math>
| output_data = <math>2n^2 + n</math>
}}

Авторы статьи: [[Участница:Davletshuna Alexandra|Давлетшина Александра]] (группа 619) пункты 1.1-1.4, 1.6, 2.7; [[Участница:Alek sandra|Зайцева Александра]] (группа 601) пункты 1.5, 1.7-1.10, 2.7.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <math>AA^*</math>;

• правые сингулярные векторы матрицы A — это собственные векторы матрицы <math>A^*A</math>.

Геометрическая интерпретация сингулярного разложения заключается в следующем факте из геометрии: ''Образом любого линейного преобразования, заданного с помощью матрицы <math>m</math>x<math>n</math>, примененного к единичной сфере является гиперэллипсоид''.

Из многочисленных разложений матриц, наиболее удобным является сингулярное разложение матрицы в виде: <math>A=U\Sigma V^*</math>, где <math>U, V</math> – унитарные матрицы, а <math>\Sigma</math> – диагональная матрица с вещественными положительными числами на диагонали <ref>http://algorithms.parallel.ru/</ref>.

Диагональные элементы матрицы <math>\Sigma</math> называются сингулярными числами матрицы <math>A</math>, а столбцы матриц <math>U,V</math> левыми и правыми сингулярными векторами соответственно.

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

''Неявный''<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 261-264)</ref> метод Якоби математически эквивалентен применению метода Якоби вычисления собственных значений к матрице <math>A = G^TG</math>.
Это значит, что на каждом шаге вычисляется вращение Якоби <math>J</math>, с помощью которого матрица <math>G^TG</math> неявно пересчитывется в <math>J^TG^TGJ</math>; вращение выбрано так, чтобы пара внедиагональных элементов из <math>G^TG</math> обратилась в нули в матрице <math>J^TG^TGJ</math>. При этом ни <math>G^TG</math>, ни <math>J^TG^TGJ</math> не вычисляются в явном виде; вместо них вычисляется матрица <math>GJ</math>. Поэтому алгоритм называется ''методом односторонних вращений''.

=== Математическое описание алгоритма ===
Исходные данные: матрица <math>G</math> (элементы <math>g_{ij}, i, j = 1, \ldots, n</math>).

Вычисляемые данные: матрица <math>\Sigma = diag(\sigma_{i})</math>, где <math>\sigma_{i}</math> - сингулярные числа, <math>U</math> - матрица левых сингулярных векторов, <math>V</math> - матрица правых сингулярных векторов.

симметричную матрицу <math>A = (G^TG)</math> можно привести к диагональному виду:
<math>RG^TGR^T</math>, где

<math>
R(j,k,\theta) =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>.

Перемножив матрицы <math>RG^TGR^T</math>, получим следующие выражения<ref>http://www.astro.tsu.ru/OsChMet/5_2.html</ref>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)} \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Т.к внедиагональные элементы должны быть равны 0, то выбираем <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>.

Тогда решая уравнение получаем, что

<math>
\begin{align}
\tau &= {a_{jj} - a_{kk}}/{2a_{jk}} \\
t &= {sign(\tau)}/(|\tau| + \sqrt{1 + \tau^2}) \\
c &= 1/(\sqrt{1 + t^2}) \\
s &= ct \\
\end{align}</math>

Остановка вычислений алгоритма наступает, когда внедиагональные элементы становятся меньше некоторого наперед заданного числа <math>\varepsilon</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма составляет непосредственно вычисление одностороннего вращения Якоби, т.е. вычисление элементов матрицы <math>g_{jm}^{(i+1)} = g_{mj}^{(i+1)}</math> и <math>g_{km}^{(i+1)} = g_{mk}^{(i+1)}</math>, <math>m \ne j,k</math>, а также вычисления элементов <math>g_{jj}^{(i+1)} </math> и <math>g_{kk}^{(i+1)} </math>, получившихся после умножения промежуточной матрицы на матрицу вращений Якоби:

<math>\begin{align}
g_{jj}^{(i+1)} &= c^2\, g_{jj}^{(i)} - 2\, s c \,g_{jk}^{(i)} + s^2\, g_{kk}^{(i)} \\
g_{kk}^{(i+1)} &= s^2 \,g_{jj}^{(i)} + 2 s c\, g_{jk}^{(i)} + c^2 \, g_{kk}^{(i)} \\
g_{jk}^{(i+1)} &= g_{kj}^{(i+1)} = (c^2 - s^2 ) \, g_{jk}^{(i)} + s c \, (g_{kk}^{(i)} - g_{jj}^{(i)} ) \\
g_{jm}^{(i+1)} &= g_{mj}^{(i+1)} = c \, g_{jm}^{(i)} - s \, g_{km}^{(i)} & m \ne j,k \\
g_{km}^{(i+1)} &= g_{mk}^{(i+1)} = s \, g_{jm}^{(i)} + c \, g_{km}^{(i)} & m \ne j,k \\
g_{ml}^{(i+1)} &= g_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

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

#Вычисление <math>\tau, c, s, t</math>.
#Одностороннее вращение матрицы.

Что требует <math>O(n)</math> операций.

После этого необходимо:

#Вычислить сингулярные числа <math>\sigma_i</math>. Что требует <math>O(n)</math> операций.
#Вычислить <math>U</math> и <math>V</math>. Что требует <math>O(n^2)</math> операций.

=== Схема реализации последовательного алгоритма ===
Применение метода Якоби к матрице <math>A = (G^TG)</math> можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 261-263)</ref>:

Если <math>G = U\Sigma V^T</math> и <math>\Sigma = diag(\sigma_{i})</math>, то алгоритм вычисляет сингулярные числа <math>\sigma_{i}</math>, матрицу <math>U</math> левых сингулярных векторов и матрицу <math>V</math> правых сингулярных векторов по следующей схеме:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
обратиться к процедуре '''''One-Sided-Jacobi-Rotation<math>(G,j,k)</math>'''''
end for
end for
пока <math>G^TG</math> не станет достаточно близка к диагональной матрице
Положить <math>\sigma_{i} = ||G(:,i)||_2 </math> (норма <math>i</math>-го столбца в <math>G</math>)
Положить <math>U = [u_{1},\dots, u_{n}]</math>, где <math>u_{i} = G(:,i)/\sigma_{i}</math>
Положить <math>V = J</math>, где <math>J</math> - накопленное произведение вращений Якоби.

Где процедура '''''One-Sided-Jacobi-Rotation''''' является метод односторонних вращений Якоби:

proc '''''One-Sided-Jacobi-Rotation<math>(G,j,k)</math>'''''
вычислить <math>a_{jj} = (G^TG)_{jj}, a_{jk} = (G^TG)_{jk}</math> и <math>a_{kk} = (G^TG)_{kk}</math>
if <math>|a_{jk}|</math> не слишком мал
<math>
\begin{align}
\tau &= {a_{jj} - a_{kk}}/{2a_{jk}} \\
t &= {sign(\tau)}/(|\tau| + \sqrt{1 + \tau^2}) \\
c &= 1/(\sqrt{1 + t^2}) \\
s &= ct \\
G &= GR(j,k,\theta) \ \dots c=cos\theta, s=sin\theta \end{align}</math>
if нужны правые сингулярные векторы
<math>J = JR(j,k,\theta)</math>
end if
end if

=== Последовательная сложность алгоритма ===
Для одного вращения Якоби необходимо выполнить <math>O(n)</math> операций умножения и сложения.

Всего вариантов выбора <math>j</math> и <math>k</math> существует <math>\frac{n(n-1)}{2}</math>.

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

=== Информационный граф ===
Граф алгоритма состоит из четырех групп вершин

(А)Первая группа вершин расположена в двумерной области, соответствующая ей операция - вычисление элементов <math>a_{jj},a_{jk},a_{kk}</math> матрицы произведения <math>A = (G^TG)</math>. Где <math>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

Граф вычисления каждого из элементов приведен на рисунке 1, где значениям <math>g_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>g^T_{ij}</math> обозначения <math>z_{ij}</math>. Значение <math>s_{ij}</math> является значением результирующего элемента.

(Б)Вторая группа вершин расположена в двумерной области, соответствующая ей операция – вычисление <math>c</math> и <math>s</math>.

Информационный граф с входными и выходными данными вычисления пункта (Б) представлен на рисунке 2.

(В)Третья группа вершин расположена в двумерной области, соответствующая ей операция вычисление значений элементов <math>g_{jm}^{(i+1)} = g_{mj}^{(i+1)}</math> и <math>g_{km}^{(i+1)} = g_{mk}^{(i+1)}</math>, <math>m \ne j,k</math>.

(Г)Четвертая группа вершин расположена в двумерной области, соответствующая ей операция вычисление значений элементов <math>g_{jj}^{(i+1)} </math> и <math>g_{kk}^{(i+1)} </math>.

Элементы групп (В) и (Г) вычисляются аналогично вычислению элементов матрицы произведения, т.к. фактически представляют собой перемножение матриц <math>G</math> и <math>R</math>

[[File:Jacobi_2.jpg|none|thumb|1000px|Рисунок 1. Информационный граф с входными и выходными параметрами вычисления каждого элемента матрицы произведения.]]

[[File:Jacobi_1.jpg|none|thumb|1000px|Рисунок 2. Информационный граф с входными и выходными параметрами вычисления значений <math>c</math> и <math>s</math>.]]

Обобщенный граф метода Якоби представлен на рисунке 3, где буквами А, Б, В и Г обозначено вычисление групп вершин (А), (Б), (В) и (Г).

[[File:Graf21.png|none|thumb|2000px|Рисунок 3. Обобщенный граф алгоритма вычисления сингулярных чисел и векторов методом Якоби.]]

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации метода Якоби требуется последовательно выполнить несколько ярусов:
# вычислить <math>\tau</math>
# вычислить <math>t</math>
# вычислить <math>c</math>
# выполнить поворот матрицы <math>G</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>g_{jm}^{(i+1)} = g_{mj}^{(i+1)}</math> и <math>g_{km}^{(i+1)} = g_{mk}^{(i+1)}</math>, <math>m \ne j,k</math>, а также вычисления элементов <math>g_{jj}^{(i+1)} </math> и <math>g_{kk}^{(i+1)} </math>.

Суммарное количество итераций равно <math>\frac{n(n-1)}{2}</math> (Различные варианты выбора <math>j</math> и <math>k</math>).

Асимптотически метод сходится квадратично.

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>G</math> размера <math>n</math>х<math>n</math>, где <math>A= G^TG</math> – симметрическая матрица.

'''Объём входных данных''': <math>n^2</math> (т.к. для хранения матрицы <math>G</math> используем двумерный массив размера <math>n</math>х<math>n</math>)

'''Выходные данные''': <math>\sigma_{i}</math> - сингулярные числа, матрица <math>U</math> левых сингулярных векторов и матрица <math>V</math> правых сингулярных векторов.

'''Объём выходных данных''': <math>2n^2 + n</math> (т.к. необходимо хранить вектор сингулярных чисел длины <math>n</math>, а также две матрицы <math>U, V</math> левых и правых сингулярных векторов размера <math>n</math>х<math>n</math>).

=== Свойства алгоритма ===
Метод Якоби является самым медленным из имеющихся алгоритмов вычисления сингулярных чисел и сингулярных векторов матрицы. Тем не менее, для матриц <math>G</math>, которые могут быть представлены в виде <math>G=DX</math>, где <math>D</math> - диагональная, а <math>X</math> - хорошо обусловлена, он способен вычислять сингулярные числа и вектора намного точнее, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 261-264)</ref>.

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

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

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

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

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

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

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

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK, LINPACK/EISPACK, Intel MKL <ref>http://www.alglib.net/matrixops/general/svd.php</ref>.

Так же функция Якоби реализована в пакете Matlab.

Т. к. алгоритм считается медленным, он не включен во многие известные пакеты.

== Литература ==
1. Дж. Деммель Вычислительная линейная алгебра. Изд. Мир, 2001.

Участник:Андрей Туманов/Алгоритм кластеризации категориальных данных CLOPE

2016-11-09T00:06:10Z

Lineprinter: Lineprinter переименовал страницу Алгоритм кластеризации категориальных данных CLOPE в [[Участник:Андрей Туманов/Алгоритм кластеризации кате…

{{Assignment}}

Основные авторы описания: [[Участник:Андрей_Туманов|А.Л.Туманов]] ([[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Boltonidze|А.В.Александров]] ([[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]] [[#Существующие реализации алгоритма|2.7]])

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

=== Общее описание алгоритма ===
Алгоритм CLOPE (Clustering with sLOPE<ref>Yang, Y., Guan, H., You. J. CLOPE: A fast and Effective Clustering Algorithm for Transactional Data In Proc. of SIGKDD’02, July 23-26, 2002, Edmonton, Alberta, Canada.</ref>) неирархический метод кластеризации, предназначенный для кластеризации огромных наборов категориальных данных. К достоинствам алгоритма относятся высокие масштабируемость и скорость работы и качество кластеризации, что достигается использованием глобального критерия оптимизации на основе максимизации градиента высоты гистограммы кластера. Отличается простотой программной реализации.

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

=== Математическое описание алгоритма ===
Пусть имеется база транзакций <math>D</math>, состоящая из множества транзакций <math>\{t_1,t_2,...,t_n\}</math>. Каждая транзакция есть набор объектов <math>\{i_1,...,i_m\}</math>. Множество кластеров <math>\{C_1,...,C_k\}</math> есть разбиение множества <math>\{t_1,...,t_n\}</math>, такое, что <math>C_1 \cup \dots \cup C_k=\{t_1,...,t_n\}</math> и <math>C_i \ne \empty</math> и <math>C_i \cap C_j = \empty </math>, для <math>i \ge 1, k \ge j</math>. Каждый элемент <math>C_i</math> называется кластером, а <math>n, m, k</math> – количество транзакций, количество объектов в базе транзакций и число кластеров соответственно.

Каждый кластер <math>C</math> имеет следующие характеристики:
[[Файл:ExampleCLOPE.jpg|500px|thumb|right]]
<math>D(C)</math> – множество уникальных объектов;

<math>Occ(i,C)</math> – количество вхождений (частота) объекта <math>i</math> в кластер <math>C</math>;

<math>S(C)= \sum_{i \in D(C)} Occ(i,C)= \sum_{t_i \in C} \mid t_i \mid , </math>

<math>W(C)= \mid D(C) \mid ,H(C)=S(C)/W(C) </math>

Функция стоимости:

<math> Profit(C) = \frac{\sum^{k}_{i=1} G(C_i) \times \mid C_i \mid} {\sum^{k}_{i=1} \mid C_i \mid } = \frac{\sum^{k}_{i=1} \frac{S(C_i)}{W(C_i)^r} \times \mid C_i \mid} {\sum^{k}_{i=1} \mid C_i \mid } </math>

где <math>\mid C_i \mid</math> количество объектов в <math>i</math>-ом кластере, <math>k</math> – количество кластеров, <math>r</math> – коэффициент отталкивания <math>(0 < r \le 1)</math>

С помощью параметра <math>r</math> регулируется уровень сходства транзакций внутри кластера, и, как
следствие, финальное количество кластеров. Этот коэффициент подбирается пользователем. Чем больше <math>r</math>, тем ниже уровень сходства и тем больше кластеров будет сгенерировано.

Постановка задачи кластеризации алгоритмом CLOPE выглядит следующим образом:

для заданных <math>D</math> и <math>r</math> найти разбиение <math>C</math> такое, что:
<math>Profit(C) \longrightarrow max </math> <ref>Нейский И.М. Классификация и сравнение методов кластеризации.</ref>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит в вычислении на каждой итерации стоимости добавления и удаления транзакции из кластера:

*вычисление нового размера кластера <math>S_{new}(C_i)=S(C_i) \pm \mid(t_n)\mid </math>, где <math>\mid(t_n)\mid</math> - длина транзакции

*вычисление новой ширины кластера <math>W_{new}(C_i)=\mid D(C_i \cup t_n)|</math>

*вычисление стоимости <math>\frac{S_{new}(C_i)(\mid C_i \mid \pm 1)}{W_{new}(C_i)^r} - \frac{S(C_i) \mid C_i \mid }{W(C_i)^r}</math>

=== Макроструктура алгоритма ===
Алгоритм состоит из следующих этапов:

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

2. '''Итерация'''. На данном этапе для каждой транзакции проводится попытка перемещения в другой кластер для максимизации функции стоимости.

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

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

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

Вычисления происходят до тех пор, пока за итерацию происходит хотя бы одно перемещение транзакции. Если за итерацию не было произведено ни одного перемещения, то текущее состояние кластеров является устойчивым и оптимальным. <ref>Павлин Н. Кластеризация категорийных данных: масштабируемый алгоритм CLOPE, https://basegroup.ru/community/articles/clope</ref>

'''Схема реализации на псевдокоде:'''

Входные параметры:

* <math>t</math> - транзакции

* <math>r</math> - коэффициент отталкивания

Выходной параметр:

* <math>C</math> кластеры, в начале алгоритма - пустое множество

'''Инициализация:'''
'''for''' t_i in t:
max = 0
'''for''' C_j in C:
'''if''' DeltaAdd(C_j,t_i,r) > max:
max = DeltaAdd(C_j,t_i,r)
C_best = C_j
'''put''' t_i in C_best

'''Итерации:'''
move = True
'''while''' move == True:
move = False
'''for''' t_i in t:
max = 0
C_now = t_i.cluster
removeCost = DeltaRemove(C_now,t_i,r)
'''for''' C_j in C:
'''if''' DeltaAdd(C_j,t_i,r) + removeCost > max:
max = DeltaAdd(C_j,t_i,r) + removeCost
C_best = C_j
if max > 0
'''del''' t_i from C_now
'''put''' t_i in C_best
move = True

Вспомогательная функция '''DeltaAdd''':
'''function''' DeltaAdd(C,t,r)
S_new=C.size + t.itemCount
W_new=C.wigth
'''for''' item in t_i:
'''if''' C_j.occ(item) = 0
''W_new = W_new + 1
'''return''' S_new * (C.count+1) / (W_new ^ r) - (C.size * C.count) / (C.wigth ^ r)

Вспомогательная функция '''DeltaRemove''':
'''function''' DeltaRemove(C,t,r)
S_new=C.size - t.itemCount
W_new=C.wigth
'''for''' item in t:
'''if''' C_j.occ(item) = 1
''W_new = W_new - 1
'''return''' S_new * (C.count-1) / (W_new ^ r) - (C.size * C.count) / (C.wigth ^ r)

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

В соответствии с ранее введенным обозначением <math>n</math> - количество транзакций, <math>m</math> - длина транзакции(максимальная), <math>k</math> - количество кластеров.

Основные вычисления восполняются в функции DeltaAdd/DeltaRemove: производится 1 сложение, не более <math>m</math> сложений/вычитаний, 2 умножения, 2 деления, 2 возведения в степень и 1 сложение - итого <math>m + 8</math> операций.

Операции выполняются для всех транзаций (<math>n</math> штук) и для всех кластеров (<math>k</math> штук). Итого выполняется <math>n*k*(m+8)</math> операций.

В добавок к этому при добавлении/удалении транзакции к кластеру производится пересчет его характеристик: <math>m+2</math> операции.

Из того можно сделать вывод, что оценка сложность алгоритма равна <math>O(n*k*m)</math>.

=== Информационный граф ===
На этапе инициализации при обработке каждой транзакции количество кластеров может как увеличиться, так и остаться неизменным. Это показано пунктирными линиями:
[[Файл:InitCLOPE.jpg|400px|center|Инициализация]]
На этапе итерации функции DeltaAdd/DeltaRemove могут считать параллельно для каждой транзакции
[[Файл:IterCLOPE.jpg ‎|400px|center|Итерации]]

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

Вычисление стоимости добавления/удаления транзакции, которые выполняются функциями DeltaAdd/DeltaRemove, происходит независимо для всех <math>k</math> кластеров. Поэтому все вычисления можно производить параллельно. Таким образом сложность алгоритма с <math>O(n*k*m)</math> понижается до <math>O(n*m)</math>.

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

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

<math>n</math> транзакций длины <math>m</math> и коэффициент отталкивания <math>r</math>

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

метки классов для каждой транзакции в соответствии с проведенной кластеризацией(числовая последовательность длины <math>n</math>)

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

* Соотношение последовательной и параллельной сложности алгоритма определяется количеством кластеров: <math>\dfrac{O(n*k*m)}{O(n*m)} = k</math>
* [[глоссарий#Вычислительная мощность|''Вычислительная мощность'']] алгоритма равна <math>\dfrac{nk(m+8) + m + 2}{nm + n + 1} \cong k</math>
* Алгоритм не является [[глоссарий#Устойчивость|''устойчивым'']], так как результат работы зависит от порядка чтения транзакций и от текущего набора транзакций в кластере.
* Выполняется свойство сбалансированности операций между параллельными ветвями алгоритма, так как для каждой транзакции выполняются функции DeltaAdd/DeltaRemove, считающие стоимость добавления/удаления транзакции.
* Свойство [[глоссарий#Детерминированность|''детерминированности алгоритмов'']] не выполняется, так как результат алгоритма зависит от порядка прохождения транзакций. Но если рассматривать транзакции как нумерованный список, то результат будет определен однозначно от запуска к запуску. Однако существует расширение алгоритма, обеспечивающее свойство детерминированности. <ref>Li, Y., Le, J., Wang, M. Improving CLOPE’s Profit Value and Stability with an Optimized Agglomerative Approach. Algorithms 2015, 8, 380-394.</ref>.
* Так как алгоритм предназначен для кластеризации категориальных данных, то он практически неприменим для числовой кластеризации.
* Быстро работает даже для большого количества данных, обеспечивая при этом хорошее качество кластеризации
* Имеет простую реализацию

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

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

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

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

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

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

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

=== Существующие реализации алгоритма ===
* http://weka.sourceforge.net/doc.stable/weka/clusterers/CLOPE.html - реализация в open source библиотеке для анализа данных WEKA(Waikato Environment for Knowledge Analysis) на языке Java
Также существуют пользовательские реализации алгоритма:
* https://github.com/infozor/php_mysql_clustering_clope - реализация алгоритма на PHP
* https://github.com/Tolsi/scala-clope - реализация алгоритма Scala

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

Участник:Андрей Туманов/Алгоритм кластеризации категориальных данных CLOPE

2016-11-09T00:05:48Z

Lineprinter:

Участник:Bagnikita/Face Recognition

2016-11-03T12:00:19Z

Lineprinter: Lineprinter переименовал страницу Face Recognition в Участник:Bagnikita/Face Recognition без оставления перенаправления

{{Assignment|Algoman}}

{{algorithm
| name = Распознавание лиц
| serial_complexity = <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>w*h*c</math>
| output_data = <math>O(k)</math>
}}

Основные авторы описания: [[Участник:Bagnikita|Н.Ю.Багров]]

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

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

Распознавание лиц при помощи компьютера было впервые предложено в 1966 г. Woody Bledsoe и др. В первой системе использовался графический планшет, на котором было необходимо вручную отметить ключевые особенности на лице (брови, губы и тд). Система в дальнешейм использовала расстояния между этими точками для сравнения разных изображений. Поскольку требовалось много ручной работы, то оператор мог обработать около 40 изображений в час. В 1997 была создана система, которая непосредственно работала с видеоданными и могла применяться на практике. В дальшейшем с увеличением производительности вычислительных систем появились более качественные алгоритмы, но они заметно уступали человеку на данной задаче. С появлением высокороизводительных видеокарт в 2014 году появились системы<ref>Taigman Y. et al. Deepface: Closing the gap to human-level performance in face verification //Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. – 2014. – С. 1701-1708.</ref>, точность которых уже превышала точность оператора (человека). Основное преимущество таких систем в том, что они могут обрабатывать большие объемы данных - производительность человека намного ниже (требуется несколько секунд на сравнение пары изображений).

Задачу распознавания лиц можно разбить на несколько этапов:

* обучение нейронной сети
* построение биометрического шаблона
* сравнение биометрических шаблонов
* поиск в базе и формирование результата

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

Алгоритм состоит из построения биометрических шаблонов (дескрипторов) по изображению и поиску заданного шаблона в базе уже вычисленных дескрипторов.

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

==== Обучение сверточной нейронной сети ====

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

Сложность задачи вычисления свертки зависит квадратично от размера фильтра и линейно от количества выходных данных.

<math>FeatureMap = A^{n, w * h} * B^{w * h, c * k^2}</math>, где <math>FeatureMap</math> - результат применения свертки, а <math>A</math> и <math>B</math> - входное изображение и матрица весов слоя нейронной сети

Существуют библиотеки, например, NVIDIA cuDNN<ref>https://developer.nvidia.com/cudnn</ref>) которые решают данную задачу более эффективно. Например, свертки размером 3x3, 5x5 могут быть реализованы с использованием FFT (что работает на видеокарте быстрее, чем умножение матриц)

==== Построение биометрического шаблона ====

Будем называть биометрическим шаблоном вектор <math>{R}^d</math>, который является представлением лица человека. Этот вектор получается после применения нейронной сети к изображению - в качестве такого вектора используют отклики с одного последних слоев нейронной сети. Для обеспечения возможности сравнивать между собой эти шаблоны вектор нормализуют.

==== Сравнение биометрических шаблонов ====

На предыдущем этапе был получен вектор значений <math>D={A}^d</math>, где d - размерность дескриптора. Можно рассматривать достаточно много различных оценивающих функций (метриками их называть некорректно, т.к для них не всегда выполняется неравенство треугольника). Например, в качестве такой функции можно рассматривать cosine distance - косинус угла между векторами-признаками в d-мерном пространстве. Также достаточно часто используют L2 метрику, либо более сложные контрукции, такие как JointBayesian<ref>Chen D. et al. Bayesian face revisited: A joint formulation //European Conference on Computer Vision. – Springer Berlin Heidelberg, 2012. – С. 566-579.</ref>. У всех таких "метрик" есть преимущества и недостатки, например в L2 можно легко проводить кластеризацию, тогда как в JointBayes и cosine metric нет. JointBayes можно дообучить на целевой выборке и повысить точность работы алгоритма.

==== Поиск в базе и формирование результата ====

Предположим, что для каждого человека в базе есть несколько фотографий. Тогда после выполнения операции сравнения биометрических шаблона изображения-запроса <math>P</math> и всех изображений в базе <math>G={g1,g2,...,gn}</math> необходимо выбрать результат с максимальным значением оценивающей функции для данного человека. Т.е необходимо оставить в результате только уникальные по людям совпадения, выбрав при этом максимальное значение при удалении дубликатов по людям.

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

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

Основные операции составляют построение биометрического шаблона, и поиск в базе

==== Построение биометрического шаблона ====

Обозначим за <math>E(w,h,c)</math> сложность операции вычисления биометричсекого шаблона по входному изображению лица человека. Поскольку сверточной нейронной сети с полносвязными слоями должно подаваться на вход изображения фиксированного размера, то необходимо изменить разрешение исходного изображения. В данной реализации алгоритма распознавания лиц используется билинейная интерполяция. Нейронная сеть получает на вход одноканальные изображения размером <math>100*100</math>. Поэтому число необходимых операций (по операциям умножения) можно оценить как <math>O(w*h*c) + O(100 * 100 * 6) = O(w*h*c) + Const</math>. На практике эта константа существенна, поскольку эти операции неоднородны по памяти.

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

В реализации, предлолженной в практической части, используются более 10 сверточных слоев. Количестве операций можно оценить исходя из количества весов связей в нейронной сети - 80M и размера сверток <math>3*3</math>. Оценка числа операций получилась ~2 GFlops на одну операцию применения нейросети (forward pass, 180ms). Она согласуется с реальным временем работы системы и производительностью системы на тесте linpack (130GFlops 4 cores) на ноутбуке.

==== Поиск в базе ====

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

===== Сравнение между собой двух дескрипторов изображений и вычисление метрики по базе =====

В практической реализации алгоритма используется косинусовая метрика <math>M(x,y)=\frac{(x,y)}{\lVert x \lVert * \lVert y \lVert}</math>. Заметим, что вектора <math>x, y</math> уже нормированы на предыдущем этапе. Поэтому число операций для вычисления метрики составляет <math>d</math> умножений и <math>d - 1</math> сложений, где d - размерность дескриптора. Если размер базы <math>n</math>, то число операций <math>O(n*d+n*(d-1))=O(n*d)</math>.

===== Агрегация результатов по людям =====

Для выполнения операции unique (без использования дополнительной памяти) необходимо отсортировать элементы (person_id, match_score) массива по ключу person_id, а при совпадении по score. После этого можно за линейное время удалить дубликаты по person_id, оставив первый элемент (который будет максимальным по match_score). Сложность таких операций <math>O(n*logn+n)=O(n*logn)</math>.

===== Cортировка по убыванию метрики сходства двух изображений =====

Финальная сортировка по match_score будет выполнена за O(n*logk), где k - количество результатов в выдаче. Обычно на практике число k не более 1000, поскольку обработка результата чаще всего производится вручную оператором (человеком).

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

Алгоритм содержит вычисление биометричиского шаблона, который на этой странице не приводится. Используется готовая бибилотека распознавания лиц [http://tevian.ru Tevian FaceSDK]. Предложенная параллельная реализация может работать с любой системой распознавания лиц, для которой выполнены следующие условия:
* известна метрика для сравнения
* можно получить дескрипторы (биометрические шаблоны) в явном виде

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

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

Алгоритм можно представить в виде следующего фрагмента псевдокода (он менее эффективный, чем предложенный выше. Эффективная реализация на c++):

<source lang='python'>
desc = enroll(Image) # Image - изображение лица человека
matches = {}
for gallery_entry in G:
if matches.get(gallery_entry.person_id, None) is None:
matches[gallery_entry.person_id] = 0.0
matches[gallery_entry.person_id] = max(matches[gallery_entry.person_id], match(desc, gallery_entry.descriptor))
matches = sorted(key = lambda x: x[1], matches.items())
return [x[0], applyMapping(x[1]) for x in matches]
</source>

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

Если рассматривать всю последовательность действий (построение шаблона, поиск в базе), то сложность алгоритма <math>O(E(w,h,c)+n*d+n*logn+n*logk+CNNConst)</math>, где
*<math>n</math> - число элементов в базе
*<math>d</math> - размерность биометрического шаблона
*<math>E(w,h,c)</math> - сложность обработки изображения размером (width*height*channels) до необходимого размера для нейросети
*<math>n*d</math> - число операций для вычисления метрики между запросом и базой
*<math>n*logn</math> - сортировка результата для удаления дубликатов
*<math>n*logk</math> - сортировка результата по значению оценивающей функции

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

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

На втором шаге уже есть посчитанный биометрический шаблон (дескриптор) - его необходимо сопоставить в базой (пусть в ней N дескрипторов). Предположим, что доступно Q исполнителей (процессов или потоков). Тогда возможна паралельная обработка Q диапазонов базы размером N/Q. Для каждого такого вычисления длина последовательной части <math>N/Q*d</math>, где d - размерность дескриптора.

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

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

[[Файл:Facerecognition-graph.png|thumb|center|700px|Рисунок 0. Граф параллельного алгоритма]]

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

Сложность параллельного алгоритма, в предположении доступности q узлов: <math>O(k*logk+q*(log(k*q))^2+\frac{n}{q}*(d+log(\frac{n}{q}))+\lambda*(k*log(q)+q*(log(q*k))^2))</math>, где
* n - размер базы изображений лиц
* d - размерность биометрического шаблона
* k - количество результатов в выдаче (k << n)
* <math>\lambda</math> - флаг (0 или 1), нужно ли производить агрегацию результатов по людям

Данная оценка получена с применением [http://darwin.bth.rwth-aachen.de/opus3/volltexte/2010/3502/pdf/3502.pdf параллельной сортировки].

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

Входные данные:
* изображение <math>P\in{R}^{w*h*c}</math>, где w,h,c - ширина, высота, число каналов
* база изображений лиц <math>G={g_1,g_2,g_3,...,g_n}, g_i\in{T}</math>
* T - объект, состоящий из биометрического шаблона и порядкового номера человека

Выходные данные*
* список <math>L={l_1,l_2,...,l_k}</math>, где <math>l_i\in{T}</math>
* T - объект, состоящий из числа (мера сходства двух изображений) и id (порядкового номера) человека в базе

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

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

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

Из преимуществ данного алгоритма можно назвать низкую нагрузку на сеть при обмене данными, возможность работы на множестве систем (MPI, hadoop и тд), посколько объем данных, передаваемых между узлами небольшой. Для практической реализации не требуется использования специальных коммуникаций с низкой задержкой (обмены происходят достаточно редко, время доставки сообщений не критично).

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

Построение биометрических шаблонов выполнено при помощи библиотеки распознавания лиц Tevian FaceSDK<ref>http://tevian.ru/product/facesdk</ref>. В этом разделе приводится эффективность параллельной реализации сравнения изображени лица с некоторой базой лиц.

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

В текущей версии алгоритма применяется векторизация с использованием FMA3 инструкций, что позволяет значительно ускорить работу программы. При выполнении оценки производительности системы использовалась простая реализация cosine метрики (цикл для вычисления скалярного произведения) и с использованием FMA инстукций.

Псевдокод операции mm256_fmadd (intel)

<source lang="fortran">
FOR j := 0 to 7
i := j*32
dst[i+31:i] := (a[i+31:i] * b[i+31:i]) + c[i+31:i]
ENDFOR
dst[MAX:256] := 0
</source>

В результате тестирования (процессор 6300HQ, ноутбук, база 30М биометрических шаблонов) однопоточной программы было установлено, что FMA3 версия в 5 раз быстрее по сравнению с обычным циклом (880ms vs 4600ms). Все дальнейшие экспериенты будут проводиться с FMA3 реализацией (если не указано иначе). Компиляция производится gcc 5.4 с флагами <code>-O3 -static-libgcc -static-libstdc++ -mavx -mavx2 -mfma -fopenmp</code>

Ниже приводится пример кода для вычисления дескриптора:
<source lang="c++">
pp = descriptor;
pg = gallery_ptr;
__m256 sum = _mm256_setzero_ps();
for(int j = 0; j < 16; ++j, pp += 8, pg += 8) {
sum = _mm256_fmadd_ps(_mm256_load_ps(pp), _mm256_load_ps(pg), sum);
}
const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(sum, 1), _mm256_castps256_ps128(sum));
const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
score = _mm_cvtss_f32(x32);
</source>

Для сортировки результатов и агрегации по людям используются функции из stl - вполне возможно, что можно реализовать более эффективно.

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

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

Сортировка результатов также обладает свойством локальности, поскольку массив хранится непрерывно в памяти. При небольшом размере базы (1-10M изображений) он может полностью поместиться в кэш памяти.

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

Алгоритм построен по модели map/reduce. В map происходит вычисление скалярных произведений дескриптора-запроса и элементов базы. В reduce происходит сортировка и удаление повторов.

Исходная база разбирается на блоки (chunks) по 1M биометрических шаблонов, каждый такой блок обрабатывается независимо в своем потоке (или процессе). Важно то, что в результате работы алгоритма на каждом блоке в результате получается небольшой объем данных - <math>k*(sizeof(float)+sizeof(int32_t))</math>. Такие данные можно легко передать по медленному каналу с высокой задержкой (не требуется использование InfiniBand). Также данный алгоритм можно запускать как на MPI кластерах с передачей сообщений, так и на hadoop кластерах.

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

В текущей версии системы реализован параллелизм с использованием OpenMP. Вместо OpenMP можно использовать любой метод многопоточной обработки данных, например, pthread. Сложность модификации кода минимальна, поскольку map/reduce подразумевает отсутствие зависимостей между различными блоками.

При реализации распределенной системы можно размещать разные chunks на вычислительных узлах и агрегировать результаты. Из-за небольшого размера сообщений такую систему можно легко построить в ЦОД без использования специальных коммуникаций на обычных серверах.

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

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

В дальнейшем во всех тестах будет использоваться сервер с 2x E5-2683v3 128GB RAM. MOPS - миллионы операций (для map -скалярное произведение, reduce - сортировка) в секунду.

Каждый тест проводится 20 раз, результаты усредняются.

[[Файл:Facerecognition-matcher.png|thumb|center|700px|Рисунок 1. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp]]

Т.к скорость чтения из DDR4 памяти 17GB/s (на практике немного меньше), то с 4 каналов памяти (по 2 на каждый процессор) нельзя считывать быстрее, чем 68GB/s. База 200M дескрипторов занимает 98GB ram, поэтому время 2300ms для вычисления всех скалярных произведений близко к нижней границе. Дальнейшее увеличение числа потоков на одном сервере не будет приводить к существенному ускорению работы программы.

Результаты работы reduce функции в завсимости от размера базы и числа потоков в openmp:
[[Файл:Facerecognition_reduce.png|thumb|center|700px|Рисунок 2. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp]]

Reduce этап лучше распараллеливается, поскольку в нем намного меньше число обращений к памяти. Его также можно ускорять, например подбирая оптимальный размер блока (chunk size). Для базы в 200M лиц лучшая скорость 1400ms (достигается на 20 потоках, дальше ускорения нет).

Значительное ускорение при размере базы в 100M (значение близко к 64GB) возникает предположительно из-за использование памяти второго процессора (суммарно 4 канала памяти, а не 2).

[[Файл:Facerecognition_overall.png|thumb|center|700px|Рисунок 3. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp]]

==== Исследование влияния HyperThreading на работу алгоритма ====

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

Синяя точка на графике - лучший результат c HyperThreading, красная - HyperThreading выключен.

[[Файл:Facerecognition-ht-matcher.png|thumb|center|700px|Рисунок 4. Результаты работы map функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-reduce.png|thumb|center|700px|Рисунок 5. Результаты работы reduce функции в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

[[Файл:Facerecognition-ht-overall.png|thumb|center|700px|Рисунок 6. Суммарная скорость работы системы в зависимости от размера базы и числа потоков в openmp (10-56 потоков)]]

Видно, что включение HyperThreading повышает производительность системы. Для reduce шага это ускорение значительно.

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

Эксперименты проводились на сервере с 2x E5-2683v3 128GB RAM.

Для семейства процессоров на ядре haswell возможно выполнение 32 операций умножения+сложения за такт.

Поэтому пиковая производительность <math>Rpeak=2*14*32*2.0*10^9</math>, где
* 2 - число процессоров
* 14 - количество ядер на каждом из процессоров
* 32 - количество операций за такт
* <math>2.0*10^9</math> - частота ядра без turbo boost

FLOPS алгоритма <math>k=100*10^6*128*2</math>, где
* <math>100*10^6</math> - число операций в секунду
* 128*2 - количество действий, необходимых для проведения одного сравнения

Эффективность для map = k / peak = 0.014 (1.42%)

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

Данный алгоритм должен хорошо работать как на суперкомпьютерах со специализированной сетевой частью, так и на кластерах серверов с 1/10G Ethernet за счет низкой частоты обменов. Также при необходимость его можно использовать на мобильных рабочих станциях (ноутбуках) и специализированных серверах (4x xeon E7-8XXX), которые смогут обрабатывать в реальном времени большие объемы данных (например, биометрические для всех людей в стране).

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

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

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

[[Категория:Нейронные сети]]

Обсуждение участника:Роман Землянский/Zavolskov/Zemlyanskiy

2016-11-03T11:58:17Z

Lineprinter: Lineprinter переименовал страницу Обсуждение:Zavolskov/Zemlyanskiy в Обсуждение участника:Роман Землянский/Zavolskov/Zemlyanskiy без оставления перенаправл…

Участник:Роман Землянский/Zavolskov/Zemlyanskiy

2016-11-03T11:58:16Z

Lineprinter: Lineprinter переименовал страницу Zavolskov/Zemlyanskiy в Участник:Роман Землянский/Zavolskov/Zemlyanskiy без оставления перенаправления

{{Assignment|IgorS}}

'''Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы'''

Авторы статьи:

'''Завольсков Владислав'''

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

[[#Макроструктура алгоритма]]

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

[[#Информационный граф]]

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

'''Землянский Роман'''

[[#Общее описание алгоритма]]

[[#Математическое описание алгоритма]]

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

[[#Ресурс параллелизма алгоритма]]

[[#Входные и выходные данные алгоритма]]

[[#Свойства алгоритма]]

614 группа

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&& \\
&&b_{m} & b_{m} \\
&&b_{m} & b_{m} \\
&&&&& \\
\end{bmatrix}

= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>:
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}vv^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}
</math>,

где

<math>
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v
</math>

так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.

Следовательно, <math>T</math> имеет те же собственные значения, что и пдобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.

Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.

Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда

<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.

'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Таким образом,

<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> ,

т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).

[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]

Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.

Доказательство.

<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math>

<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math>

<math>=u + \alpha(D - \alpha I)^{-1}u - u</math>

поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>

<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.

Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе.

Алгоритм является рекурсивным.

=== Дефляция ===

До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.

Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>

== Макроструктура алгоритма ==
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].

[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]

[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]

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

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис. 4. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.4 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.

[[File:GraphNewton.png|thumb|center|800px|Рис. 4. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math>

для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что

<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.

Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция

<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)

Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math>

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция

<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math>

Удовлетворяла условиям

<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)

Наконец, полагаем

<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math>

<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.

== Схема реализации последовательного алгоритма ==
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе'''

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>

<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>

<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>

<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math>

На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.

== Информационный граф ==
В данном разделе представлен информационный граф алгоритма: на рисунке 5 изображена часть алгоритма, в которой происходит деление - "Divide", а на рисунке 6 описана часть "Conquer".

[[File:Divide.jpg|thumb|center|left|800px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]

[[File:ConquerPart.jpg|thumb|center|1200px|Рис. 6. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Conquer</b>. Qk*k - матрица собственных значений размерности <b>k</b>. Lk*k - матрица собственных векторов размерности <b>k</b>.]]

Операции:

<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math>

Индексы - размерность

<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math>

<math> L_{k} </math> - операция поиска собственных значений

<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math>

<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math>

== Ресурс параллелизма алгоритма ==
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму.

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

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

В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.

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

На вход алгоритму подаётся трёхдиагональная симметричная матрица:

<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
</math>

'''Объем входных данных:'''

<math>\frac{n (n + 1)}{2}</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.

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

На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.

'''Объем выходных данных:'''

<math> n + n^{2} = n(n + 1) </math>

== Свойства алгоритма ==
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.

Последовательная сложность алгоритма: <math> t = c\frac{4}{3}n^{3} </math>

Параллельная сложность алгоритма (в силу использования дефляции): <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).

Особенности алгоритма:

1. Использование дефляции ([[#Дефляция]])

2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])

= ЧАСТЬ. Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

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

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

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

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

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

== Существующие реализации алгоритма ==
Большого количества реализаций данного алгоритма найдено не было: единственный пример описан на страницах 7, 19 и 20 в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье], которая указана в списке литературы.

= Литература =
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235

[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]

[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]

[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]

[[en:Description of algorithm properties and structure]]

Участник:Elijah/Нахождение собственных чисел квадратной матрицы методом QR разложения

2016-11-01T15:46:16Z

Lineprinter: Lineprinter переименовал страницу Нахождение собственных чисел квадратной матрицы методом QR разложения в [[Участник:Elijah/Нахождение собстве…

{{Assignment}}

{{algorithm
| name = Нахождение собственных чисел квадратной матрицы методом QR разложения
| serial_complexity = <math>N * O(n^3)</math>
| pf_height = <math> N * (12n - 15) </math>
| pf_width = <math> O(n^2) </math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Основные авторы описания: <br>
[[Участник:Elijah|И.В.Афанасьев]], разделы [[#Вычислительное ядро алгоритма|1.3]] - [[#Свойства алгоритма|1.10]] (базовый алгоритм), [[#Особенности реализации последовательного алгоритма|2.1]], [[#Возможные способы и особенности параллельной реализации алгоритма|2.3]], [[#Масштабируемость алгоритма и его реализации|2.4]], [[#Существующие реализации алгоритма|2.7]] <br>

[[Участник:Vladbrim|В.А.Шишватов]], разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]] - [[#Свойства алгоритма|1.10]] ((алгоритм с преобразованием к матрице Хессенберга) <br>

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

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

QR-алгоритм — это численный метод в линейной алгебре, предназначенный для решения полной проблемы собственных значений, то есть отыскания всех собственных чисел и собственных векторов матрицы. Был разработан в конце 1950-х годов независимо В. Н. Кублановской и Дж. Фрэнсисом. [https://ru.wikipedia.org/wiki/QR-алгоритм] <br>

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

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

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

==== QR-алгоритм нахождения собственных чисел====

Пусть <math>A</math> — вещественная матрица, для которой мы хотим найти собственные числа. Положим <math>A_0 = A</math>. На <math>k</math>-ом шаге (начиная с <math>k = 0</math>) вычислим QR-разложение <math>A_k = Q_k R_k</math>, где <math>Q_k</math> — ортогональная матрица (то есть <math>Q_k^\text{T} = Q_k^{-1}</math>), а <math>R_k</math> — верхняя треугольная матрица. Затем мы определяем <math>A_{k+1} = R_k Q_k</math>.

Заметим, что
: <math> A_{k+1} = R_k Q_k = Q_k^{-1} Q_k R_k Q_k = Q_k^{-1} A_k Q_k = Q_k^{T} A_k Q_k, </math>
то есть все матрицы <math>A_k</math> являются подобными, то есть их собственные значения равны.

Пусть все диагональные миноры матрицы <math>A</math> вырождены. Тогда последовательность матриц <math>A</math> при <math> k \rightarrow \infty</math> сходится по форме к клеточному правому треугольному виду, соответствующему клеткам с одинаковыми по модулю собственными значениями.
<ref>Численные методы / Н. С. Бахвалов, Н. П. Жидков, Г. М. Кобельков. — 3-е изд. — М: БИНОМ, Лаборатория знаний, 2004. — С. 321. — 636 с.</ref>

==== Сходимость QR-алгоритма нахождения собственных чисел ====

Сходимость QR-алгоритма определяется как сходимость поддиагональной подматрицы матрицы <math>A_k</math> (<math>A_k = R_{k-1}Q_{k-1}</math>) к нулевой матрице.

Предположим, что для матрицы <math>A \in \mathbb{C}^{n \times n}</math> выполнены следующие условия:

# <math>A = X \Lambda X^{-1}, \quad \Lambda = \begin{bmatrix} \Lambda_1 & 0 \\ 0 & \Lambda_2 \end{bmatrix}, \quad \Lambda_1 \in \mathbb{C}^{m \times m}, \quad \Lambda_2 \in \mathbb{C}^{r \times r}</math>;
# <math>\left | \lambda_1 \right | \ge \ldots \ge \left | \lambda_m \right | > \left | \lambda_{m+1} \right | \ge \ldots \ge \left | \lambda_{m+r} \right | > 0, \quad \{ \lambda_1, \ldots, \lambda_m \} = \lambda(\Lambda_1), \quad \{ \lambda_{m+1}, \ldots, \lambda_{m+r} \} = \lambda(\Lambda_2)</math>;
# ведущая подматрица порядка <math>m</math> в <math>X^{-1}</math> невырожденная.

Пусть QR-алгоритм порождает последовательность матриц вида:

:<math>A_k = \begin{bmatrix} A_{11}^{(k)} & A_{12}^{(k)} \\ A_{21}^{(k)} & A_{22}^{(k)} \end{bmatrix}</math>.

Тогда <math>A_{21}^{(k)} \rightarrow O</math> при <math> k \rightarrow \infty</math>. При достижении необходимой точности матрицу <math>A_{21}^{(k)}</math> можно заменит нулевой матрицей. В таком случае собственные значения необходимо искать для матриц <math>A_{11}^{(k)}</math> и <math>A_{22}^{(k)}</math>.

Если условия 1-3 выполнены для всех <math>m \in \{1, ..., n-1\}</math>, то все поддиагональные матрицы сходятся к нулевым матрицам. Таким образом, все элементы, лежащие ниже главной диагонали стремятся к нулю, и диагональные элементы матриц <math>A_k</math> сходятся к искомым собственным значениям матрицы <math>A</math><ref>Тыртышников Е.Е. Методы численного анализа. — М.: Академия, 2007. — 320 c.</ref>

==== Приведение матрицы к матрице Хессенберга ====

Для преобразования матрицы к матрице Хессенберга<ref>[https://en.wikipedia.org/wiki/Hessenberg_matrix| Hessenberg matrix]</ref> используется преобразование Хаусхолдера<ref>[https://en.wikipedia.org/wiki/Householder_transformation#Tridiagonalization| Tridiagonalization using Householder transformation]</ref>.

Для каждого <math> k = 1,2,... n-1 </math>

:<math> \displaystyle \alpha = -\operatorname{sgn}(a^k_{k+1,k})\sqrt{\sum_{j=k+1}^{n}(a^k_{jk})^2} </math>;

:<math> r = \sqrt{\frac{1}{2}(\alpha^{2}-a^k_{k+1,k}\alpha)} </math>;

:<math>v^k_1 = v^{k}_2 = \cdots = v^k_k=0;</math>

:<math> v^{k}_{k+1} = \frac{a^{k}_{k+1,k}-\alpha}{2r}</math>

:<math> v^{k}_j = \frac{a^{k}_{jk}}{2r}</math>, для <math>j = k+2; k+3, ..., n</math>

:<math> \displaystyle P^{k} = I - 2v^{(k)}(v^{(k)})^\text{T}</math>

:<math>\displaystyle A^{(k+1)} = P^{k}A^{(k)}(P^{k})^\text{T}</math>

При этом матрица <math>P</math> не вычисляется и используется напрямую. Вместо этого используются следующие вычисления
:<math>\displaystyle B^{(k)} = P^{k}A^{(k)} = (I - 2v^{(k)}(v^{(k)})^\text{T}) A^{(k+1)} = A^{(k+1)} - 2A^{(k+1)}v^{(k)}(v^{(k)})^\text{T}</math>
:<math>\displaystyle A^{(k+1)}
= P^{k}A^{(k)}(P^{k})^\text{T}
= B^{(k)}(P^{k})^\text{T}
= ((B^{(k)})^\text{T})^\text{T}(P^{k})^\text{T}
= (P^{k}(B^{(k)})^\text{T})^\text{T}
= ((B^{(k)})^\text{T} - 2B^{(k)}v^{(k)}(v^{(k)})^\text{T})^\text{T}</math>

Таким образом перемножение матриц <math>P^{k}A^{(k)}</math> и <math>B^{k}P^{(k)}</math> имеет сложность <math>O(n^2) </math>(умножения матрицы на вектор) вместо <math>O(n^3)</math> (перемножение матриц)

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

==== Базовый алгоритм ====

У базового QR алгоритма есть два вычислительных ядра:
# операция поиска QR разложения с использованием метода Гивенса
# матричное умножение полученных матриц

Для получения <math>QR</math>-разложения методом Гивенса <math>A</math> матрицу приводят к правой треугольной <math>R</math> последовательностью умножений её слева на матрицы вращения <math>T_{1 2}, T_{1 3}, ..., T_{1 n}, T_{2 3}, T_{2 4}, ..., T_{2 n}, ... , T_{n-2 n}, T_{n-1 n}</math>.

Матричное умножение может быть выполнено любым классическим способом: для плотных матриц <math>A</math> (элементы <math>a_{ij}</math>) и <math>B</math> (элементы <math>b_{ij}</math>) вычисляется плотная матрица <math>C</math>с элементами <math>c_{ij}</math> по формуле:

Формулы метода:
:<math>
\begin{align}
c_{ij} = \sum_{k = 1}^{n} a_{ik} b_{kj}, \quad i \in [1, m], \quad i \in [1, l].
\end{align}
</math>

==== Алгоритм с преобразованием к матрице Хессенберга ====

Для QR алгоритма с использования матрицы Хессенберга:
# получение матрицы Хессенберга из исходной матрицы
# операция поиска QR разложения с использованием модифицированного метода Гивенса

Для преобразования исходной матрицы к матрице Хессенберга используются преобразования Хаусхолдера (см. [[#Приведение матрицы к матрице Хессенберга| раздел 1.2.3]])

Для получения <math>QR</math>-разложения методом Гивенса для матрицы Хессенберга <math>A</math>, матрицу приводят к правой треугольной <math>R</math> последовательностью умножений её слева на матрицы вращения <math>T_{1 2}, T_{2 3}, T_{3 4}, ..., T_{(n-1)\ n}</math>. <br> <br>

Более подробное описание вычислительных ядер можно найти по соответствующим ссылкам в [[#Макроструктура алгоритма| разделе 1.4]].

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

Как уже описано в описании ядра алгоритма, базовая версия QR-алгоритма на каждой итерации использует следующие алгоритмы:
# [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)|Метод Гивенса (вращений) QR-разложения квадратной матрицы]] или [[Метод_Хаусхолдера_(отражений)_QR-разложения_квадратной_матрицы,_вещественный_вариант|Метод Хаусхолдера(отражений) QR-разложения_квадратной_матрицы]]
# [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|Перемножение плотных неособенных матриц]]

В случае использования матрицы Хессенберга:
# Получение матрицы Хессенберга из исходной матрицы с помощью преобразований Хаусхолдера<ref>[https://en.wikipedia.org/wiki/Householder_transformation| Householder transformation]</ref>.
# [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)|Метод Гивенса (вращений) QR-разложения квадратной матрицы]]. При этом количество элементов матрицы, которые нужно занулять, на порядок меньше, чем в базовом варианте.

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

==== Базовый алгоритм ====

Последовательная реализация простейшего алгоритма состоит из некоторого числа итераций

Каждая итерация состоит из следующих действий (с начальным условием <math> A_0 = A</math>):
# Для матрицы <math> A_{n} </math> строится QR разложение любым доступным последовательным алгоритмом на матрицы <math> Q_{n} </math> и <math> R_{n} </math> <br>
# Матрицы <math> R_{n} </math> и <math> Q_{n} </math> перемножаются, таким образом получается матрица <math> A_{n+1} = R_{n} * Q_{n} </math> для следующей итерации <math> n + 1 </math>
# Проверятся, приведена ли матрица к верхнетреугольной форме, и если да, то производится выход из цикла.

==== Алгоритм с преобразованием к матрице Хессенберга ====

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

Затем производится некоторое число итераций, состоящих из следующих действий (с начальным условием <math> A_0 = H</math>):
# Для матрицы <math> A_{n} </math> строится QR разложение с помощью метода вращения Гивенса. При этом занулять нужно не все элементы, а только <math> a_{i + 1, i} </math>, где <math>i \in {1, n - 1}</math>. Полученная матрица будет опять являться матрицей Хессенберга.
# Проверятся, приведена ли матрица к верхнетреугольной форме, и если да, то производится выход из цикла.

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

==== Последовательная сложность базового алгоритма ====
Рассчитаем последовательную сложность базового алгоритма. Пусть <math style="vertical-align:0%"> A \in \mathbb{R}^{n \times n}</math>, и для приведения матрицы к треугольной форме необходимо произвести N итераций алгоритма. <br>
На каждой итерации алгоритма производится QR разложение (сложностью <math style="vertical-align:0%"> 2 * n^3 </math>) и матричное умножение (сложностью <math style="vertical-align:0%"> n^3 </math>). Проверка того, имеет ли матрица треугольную форму, может быть проведена за <math style="vertical-align:0%"> n^2 </math> операций. <br>
Таким образом итоговая сложность одной итерации составляет: <math> 3*n^3 + n^2 = O(n^3)</math> <br>
Общая сложность алгоритма при <math> N </math> итерациях составляет <math> N * O(n^3) </math>

==== Последовательная сложность алгоритма с приведением матрицы к матрице Хессенбрга ====

Данный алгоритм состоит из двух этапов:
# преобразование исходной матрицы к матрице Хессенберга
# QR-разложение методом Гивенса

===== Сложность алгоритма приведения матрицы к матрице Хессенбрга =====

На каждой итерации алгоритма приведения матрицы к матрице Хессенбрга требуется вычислить:
# <math>\alpha</math> со сложность <math>O(n)</math>
# <math>r</math> со сложностью <math>O(1)</math>
# <math>v^k</math> со сложностью <math>O(n)</math>
# <math>A^{(k+1)}</math> со сложностью <math>O(n^2)</math>
Таким образом вычислительная сложность одной итерации равна <math>O(n^2)</math>.
Всего таких итераций <math>n</math>, поэтому общая сложность алгоритма равна <math>O(n^3)</math>.

===== Сложность алгоритма QR-разложения методом Гивенса =====

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

Таким образом, для произвольной матрицы одна итерация алгоритма QR-разложения имеет вычислительную сложность равную <math>O(n^3)</math>, для матрицы Хессенберга - <math>O(n^2)</math>. Проверка на то, является ли матрица треугольной, имеет сложность <math>O(n^2)</math>, что не влияет на порядок сложности.

Если всего требуется <math>N</math> итераций для преобразования матрицы к треугольному виду, то для для произвольной матрицы сложность будет <math>N * O(n^3)</math>, для матрицы Хессенберга - <math>N * O(n^2)</math>

===== Итоговая сложность =====

Таким образом, общая вычислительная сложность алгоритма вычисления собственных значений с приведением матрицы к матрице Хессенбрга равна <math>O(n^3) + N * O(n^2)</math>

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

Макрограф алгоритма изображён на рисунке 1. Он представляет из себя верхний уровень алгоритма, на котором в цикле итеративно вызываются следующие операции: <br>

# Инициализация матриц ('''init matrices''')
# QR разложение ('''QR decomposition''')
# Матричное умножение ('''matrix multiplication''')
# Проверка, приведена ли матрица к верхней треугольной форме ('''check if matrix is upper triangular''')
# Получение собственных значений из диагонали матрицы ('''get eigenvalues from matrix diagonal''')

Информационные графы [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)#.D0.98.D0.BD.D1.84.D0.BE.D1.80.D0.BC.D0.B0.D1.86.D0.B8.D0.BE.D0.BD.D0.BD.D1.8B.D0.B9_.D0.B3.D1.80.D0.B0.D1.84|QR разложения]] и [[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)#.D0.98.D0.BD.D1.84.D0.BE.D1.80.D0.BC.D0.B0.D1.86.D0.B8.D0.BE.D0.BD.D0.BD.D1.8B.D0.B9_.D0.B3.D1.80.D0.B0.D1.84|матричного умножения]] могут быть найдены по приведенным ссылкам. Информационный граф проверки того, приведена ли матрица к верхнетреугольной форме, будет приведен далее на рисунке 2. Информационные графы инициализации и получения собственных значений представляют собой работу с вводом и выводом входных/выходных данных, и, поэтому, рассматриваться не будут.

[[Файл:Screen_Shot_2016-10-15_at_12.43.32_PM.png|thumb|center|600px|Рисунок 1. Информационный граф базовой версии QR-алгоритма без отображения входных и выходных данных. N итераций.]]

[[Файл:Check_if_matrix_is_upper_triangular.png|thumb|center|300px|Рисунок 2. Информационный граф проверки приведенности матрицы к верхнетреугольной форме.]] <br>

В случае оптимизации алгоритма с приведением матрицы к форме Хессенберга, инициализация матрицы (int matrices (1)), будет включать в себя преобразование хаусхолдера, имеющее следующий граф алгоритма:

[[Файл:Hessenberg_transformation.png|thumb|center|500px|Рисунок 3. Информационный граф проверки хаусхолдера.]] <br>

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

Все итерации базового QR-алгоритма производятся последовательно, поэтому на верхнем уровне алгоритм чисто последователен. <br>

Основной ресурс параллелизма представлен на нижнем уровне, при реализации различных операций, используемых в алгоритме, таких как QR разложение методом вращений и матричное умножение. <br> <br>

==== Параллельная сложность базового QR-алгоритма ====
Посчитаем параллельную сложность каждой операции по отдельности, а затем, по полученным данным, и всего алгоритма целиком: <br>
# Параллельная сложность QR разложения методом вращений составляет <math> 11n - 16 </math> <ref name="QRGivens">[[Метод Гивенса (вращений) QR-разложения квадратной матрицы (вещественный вариант)|Метод Гивенса (вращений) QR-разложения квадратной матрицы]]</ref> <br>
# Параллельная сложность матричного умножения составляет <math> n </math><ref name="MatrixMultiplication">[[Перемножение_плотных_неособенных_матриц_(последовательный_вещественный_вариант)|Перемножение плотных неособенных матриц]]</ref>.<br>
# Параллельная сложность проверки, является ли матрица верхнетреугольной, равна n. <br>
Таким образом параллельная сложность каждой итерации составляет <math> 13n - 15 </math>. При N итерациях, которые необходимо производить последовательно, итоговая сложность базового алгоритма составляет <math> N * (13n - 15) </math>, что в упрощенном виде равно <math> N * O(n) </math> <br>

==== Параллельная сложность алгоритма с приведением матрицы к форме Хессенберга: ====
Снова вычислим параллельную сложность каждой операции по отдельности, а затем, по полученным данным, и всего алгоритма целиком: <br>
# Параллельная сложность приведения матрицы к форме Хессенберга составляет <math> O(n^2) </math>
# Параллельная сложность каждой итерации с приведенной матрицы составляет <math> O(n) </math>

Таким образом параллельная сложность всего алгоритма при N итерациях составляет <math> O(n^2) + N*O(n) </math>.

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

* '''Входные данные''': плотная квадратная матрица <math style="vertical-align:0%">A</math> (элементы <math>a_{ij}</math>).

* '''Объём входных данных''': <math style="vertical-align:0%">n^2</math>.

* '''Выходные данные''': <math>n</math> вещественных собственных чисел <math> | l_{i} | </math> матрицы <math style="vertical-align:0%">A</math>

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

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

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

Вычислительная мощность, равная отношению числа операций <math> N * O(n^3) </math> к суммарному объему входных и выходных данных <math> n^2 + n </math>, для каждой итерации линейна, а для всего алгоритма в целом равна <math> N*n </math>, что позволяет сделать вывод о том, что перемещение данных для обработки не играет важной роли в данном алгоритме.

Для оптимизированного алгоритма вычислительная мощность так же линейна (приведение матрицы к форме Хессенберга имеет сложность <math> O(n^3) </math>, а объем выходных данных <math> O(n^2) </math>).

Вычислительная погрешность растет линейно, из-за использования метода вращений для QR разложения.

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

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

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

Основным типом данных для QR алгоритма является матрица. В данной статье представлена реализация на языке C++, что накладывает определенные ограничения на формат хранени матриц: все матрицы хранятся в одномерном массиве в построчном (ROW_MAJOR) формате.

В простейшем случае QR-алгоритм выглядит следующим образом:

<source lang="C++">

int sequential_QR_algorithm(float *A, int size)
{
float *Q = new double[size * size];
float *R = new double[size * size];
while(!check_if_upper_triangular(A, size)))
{
sgeqrf (ROW_MAJOR, size, size, A, size, tau);
set_Q_and_R(A, Q, R, size);
sorgqr(ROW_MAJOR, size, size, size, Q, size, tau);
sgemm (RowMajor, NoTrans, NoTrans, size, size, size, 1, R, size, Q, size, 0, A, size);
}
}
</source>

В последовательном случае функции dgeqrf, dorgqr и dgemm представляют собой последовательные функции стандарта BLAS, вычисляющие QR разложение(geqrf), матрицу Q после разложения (dorgqr) и матричное умножение (dgemm).
Так же здесь используются простейшие функции set_Q_and_R и check_if_upper_triangular. Функция set_Q_and_R получает после QR разложения из матрицы A данные о матрицах Q и R. Функция check_if_upper_triangular проверяет, приведена ли матрица A к треугольном виду, и если да, происходит выход из цикла.

Для работы программы в памяти необходимо хранить 3 матрицы, таким образом общий объем составляет 3 * n^2. Так же необходим вспомогательный массив tau для QR разложения, однако его размер составляет всего n. Так же важно заметить, что различные реализации функций dgeqrf, dorgqr и dgemm обычно используют внутренние вспомогательные массивы для блочной обработки, однако, их размер не превышает n * C, где C - некоторая архитектурно зависимая константа.

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

Как уже говорилось ранее, внешний цикл представленной программы сугубо последователен (итеративен), и основной ресурс параллелизма расположен в вызываемых функциях (geqrf, gemm). Их реализации бывают крайне различны, поэтому данный алгоритм можно легко преобразовать для любой архитектуры, используя набор стандартных библиотечных функций. К примеру, для реализации алгоритма на GPU можно использовать библиотеку MAGMA, на многоядерных CPU - Intel MKL.

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

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

Как уже говорилось в [[#Особенности реализации последовательного алгоритма| разделе 2.1]], при использовании различных библиотек можно реализовать данный алгоритм практически на всех архитектурах. Далее более подробно будут рассмотрены примеры для некоторых из них. Особенности параллельных реализаций для базовых макроопераций (QR разложения и матричного умножения), уже описаны в соответствующих статьях (см. ссылки в [[#Макроструктура алгоритма| разделе 1.4]])

'''Реализация на многоядерных CPU (одном узле)'''

Для распарарллеливания на многоядерных CPU используются функции LAPACKE_sgeqrf, LAPACKE_sorgqr и cblas_sgemm. Распараллеливание оставшихся функций может быть произведено с использованием openMP, так как внутренние циклы в них независимы по данным.

Исходный код предложенной реализации представлен далее:

<source lang="C++">

int CPU_QR_algorithm(float *A, int size)
{
float *Q = new double[size * size];
float *R = new double[size * size];
while(!check_if_upper_triangular(A, size)))
{
LAPACKE_sgeqrf (LAPACK_ROW_MAJOR, size, size, A, size, tau);
set_Q_and_R(A, Q, R, size);
LAPACKE_sorgqr(LAPACK_ROW_MAJOR, size, size, size, Q, size, tau);
cblas_sgemm (CblasRowMajor, CblasNoTrans, CblasNoTrans, size, size, size, 1, R, size, Q, size, 0, A, size);
}
}
</source>

'''Реализация на GPU (и multi-GPU)'''

Для реализации алгоритма на GPU и multi-GPU можно использовать аналогичные функции dgemm и geqrf из библиотеки [[ Magma. http://icl.cs.utk.edu/magma/ | magma]].

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

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

Для данного алгоритма была проверена масштабируемость оптимизированной версии с приведением матрицы к форме Хессенберга. Тесты проводились для случайно сгенерированной матрицы размера 8000x8000 на 1-14 параллельных вычислительных потоках.

Код, для которого проверлась масштабируемость, реализован с помощью функций библиотеки intel MKL, выглядит следующим образом: <br>

<source lang="C++">

#include "stdio.h"
#include "stdlib.h"
#include "mkl.h"
#include "math.h"
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
int max_threads;
float *h, *Wr, *Wi, *z, *scalar, *h_copy;
double s_initial, s_elapsed;
lapack_int n = atoi(argv[1]); //size=n

h=(float*)mkl_malloc(n*n*sizeof(float),32);
h_copy=(float*)mkl_malloc(n*n*sizeof(float),32);
z=(float*)mkl_malloc(n*n*sizeof(float),32); //z will not be referenced due to set compz="N"
Wr=(float*)mkl_malloc(n*sizeof(float),32);
Wi=(float*)mkl_malloc(n*sizeof(float),32);
scalar=(float*)mkl_malloc((n-1)*sizeof(float),32);
if(h==NULL) //initilization for hessenberg matrix
{
for(int i=0;i<n*n;i++)
{
h[i]=(float)rand()*2000;
h_copy[i]=h[i];
}
}
for(int j=0;j<n*n;j++)
{
z[j]=0.0;
}
max_threads=mkl_get_max_threads();

for(int t = 1;t <= max_threads;t++)
{
double t1 = dsecnd();
mkl_set_num_threads(t);
LAPACKE_sgehrd(LAPACK_ROW_MAJOR, n, 1, n, h, n, scalar);
LAPACKE_shseqr(LAPACK_ROW_MAJOR, 'E', 'N', n, 1, n, h, n, Wr, Wi, z, n);
double t2 = dsecnd();

cout << "total time for " << t << " threads: " << t2 - t1 << endl << endl;

for(int k=0;k<n*n;k++)
{
h[k]=h_copy[k];
}
}
return 0;
}

</source>

Далее приводятся графики сильной и слабой масштабируемости.

[[file:QR_algorithm_strong_scalability.png|thumb|center|500px|Рис.4 Сильная масштабируемость оптимизированного QR алгоритма с приведением матрицы к форме Хессенберга]]

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

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

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

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

'''Последовательный''' QR алгоритм, а так же различные базовые функции для его реализации, можно найти в [http://www.netlib.org/scalapack/ библиотеке LAPACK] и её аналогах и расширениях.

Базовая версия QR алгоритма может быть реализована описанным в [[#Особенности реализации последовательного алгоритма| разделе 2.1]] способом при помощи функций:
# '''?geqrf''' - вычисляет QR разложение произвольной матрицы
# '''?gemm''' - вычисляет произведение двух плотных матриц

'''?steqr''' - вычисляет собственные числа и собственные вектора для случая тридиагональной матрицы.

Для реализации оптимизированного алгоритма с приведением матрицы к матрице Хессенберга можно использовать следующие функции:
# '''?gehrd''' - приводят матрицу общего вида к верхней матрице Хессенберга с использованием ортогональных/унитарных трансформаций
# '''?hseqr''' - вычисляют собственные значения матрицы в верхней матрице Хессенберга с использованием QR алгоритма

Подробная документация по упомянутым функциям может быть найдена [http://physics.oregonstate.edu/~landaur/nacphy/lapack/eigen.html здесь].

'''Параллельный''' QR алгоритм может быть реализован с помощью библиотек [http://www.netlib.org/scalapack/ ScaLAPACK] и [http://www.cs.utexas.edu/users/plapack/ PlaLAPACK].

'''p?geqrf''', '''p?gemm''', '''p?hseqr''' - аналогичные функции ScaLAPACK.

'''PLA_QR''', '''PLA_Gemm''' - аналогичные функции из PlaLAPACK.

== Примечания ==

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

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-01T15:45:48Z

Lineprinter: Lineprinter переименовал страницу Быстрое преобразование Фурье в Участник:Timokhinivan/Быстрое преобразование Фурье без оставления перенапра…

{{Assignment}}
{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
Преобразование Фурье переводит сигнал в его спектр и обратно, и широко
применяется в самых различных областях вычислительной математики —
собственно спектральный анализ, сжатие данных, вычисление свёрток и
т.д. В связи с этим, особый интерес представляют быстры алгоритмы для
вычисления этого преобразование. На сегодняшний день, наилучшие из
них имеют сложность <math>O(n \log n)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math>.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k\,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

Данный алгоритм уже даёт существенный выигрыш по сравнению с обычным
умножением матрицы на вектор: <math> O(m^2 n + n^2 m) </math> против
<math>O(m^2 n^2)</math>. Однако наилучших результатов можно добиться,
если применять этот алгоритм рекурсивно на этапах 2 и 4.

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math>. В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

В случае, если порядок преобразования простой, но ещё слишком большой, чтобы вычислять его непосредственно, задача усложняется. Алгоритм в этом случае такой:

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

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

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

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

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

Особо следует отметить, что если порядок элементов в выходном массиве не важен, шаг 6 можно пропустить.

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

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

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

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

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

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

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

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

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

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

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

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

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

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

В связи с этим, некоторые существующие реализации (например, Intel® MKL) просто не поддерживают этот случай. Впрочем, некоторые реализации не поддерживают большие простые делители ''вовсе''.

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

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

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-01T15:44:55Z

Lineprinter:

Участник:Maria Zaitseva/PAM (Partitioning Around Medoids)

2016-11-01T15:43:53Z

Lineprinter: Lineprinter переименовал страницу PAM (Partitioning Around Medoids) в Участник:Maria Zaitseva/PAM (Partitioning Around Medoids) без оставления перенаправления

{{Assignment|ASA}}

{{algorithm
| name = Partitioning Around Medoids
| serial_complexity = <math>O(Tkn^2)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>k</math>
}}

Авторы: [[Участник: Maria Zaitseva|Зайцева М.Ф.]], [[Участник: kovalexal|Ковальчук А.А.]].

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

'''PAM (Partitioning Around Medoids)''' – алгоритм разбиения множества объектов на [https://ru.wikipedia.org/wiki/Кластер кластеры], базирующийся на использовании наиболее представительных объектов каждого кластера ([https://ru.wikipedia.org/wiki/Медоид медоидов]) для их описания. Был разработан в 1987 году Леонардом Кауфманом и Питером Русивом <ref>Kaufman L., Rousseeuw P. J. Finding groups in data: an introduction to cluster analysis. – John Wiley & Sons, 2009. – Т. 344.</ref>. Показывает хорошие результаты разбиения на небольших наборах данных, однако имеет высокую вычислительную сложность, ввиду чего неэффективно работает на больших наборах данных.

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

== Общее описание алгоритма ==
Данный алгоритм используется для решения задачи [https://ru.wikipedia.org/wiki/Кластерный_анализ кластеризации] множества объектов на заранее известное число кластеров <math>k</math>. Каждый кластер характеризуется наиболее представительным (центральным ) объектом – медоидом. Принадлежность объекта к соответствующему кластеру определяется индексом наиболее близкого к нему медоида.

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

Алгоритм состоит из двух последовательных этапов:

1. Шаг ''BUILD''. Построение начального набора <math>k</math> медоидов путем их последовательного выбора. Первый из них выбирается как объект, сумма дистанций которого до всех других объектов минимальна (центральный объект). Каждый следующий выбирается из оставшихся объектов как лучше всего минимизирующий сумму расстояний от объектов до ближайших к ним медоидов. Выбранный набор медоидов характеризует "конфигурацию" кластеров, для которой может быть вычислена ее стоимость.

2. Шаг ''SWAP''. На данном шаге производится попытка улучшить стоимость текущей конфигурации путем перебора всех возможных замен (медоид-немедоид). Среди рассматриваемых конфигураций ищется наиболее оптимальная. В случае, если данная конфигурация по стоимости лучше текущей, она принимается в качестве текущей и шаг повторяется с начала, иначе алгоритм завершается.

Преимущества данного алгоритма по сравнению с подобными ему:

* В отличие от более популярного алгоритма [https://ru.wikipedia.org/wiki/K-means k-means], PAM позволяет работать с произвольными объектами с заданной мерой рассчета расстояний (различий), не требует хранения всего множества объектов (достаточно знать лишь матрицу дистанций, так как медоиды выбираются из множества объектов), а также более устойчив к выбросам в данных (за счет рассмотрения медоидов вместо центроидов);
* В отличие от традиционного [https://en.wikipedia.org/wiki/K-medoids k-medoids] на шаге ''BUILD'' начальные медоиды выбираются более оптимальным образом по сравнению со случайным выбором. Это позволяет уменьшить количество итераций шага ''SWAP'', тем самым сокращая время работы алгоритма.

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

== Математическое описание алгоритма ==
''Входные данные'':

* <math>o = \{1,\dots,n\} \subset \mathbb{Z}</math> –– множество индексов объектов
* <math>O = \{O_1,\dots,O_n\}</math> –– множество объектов
* <math>k \leq n</math> –– количество кластеров для разбиения
* <math>d:O\times O\rightarrow \mathbb{R}^{1}</math> –– метрика расчета расстояний между объектами, <math>d_{ij} = d(O_i,O_j)</math>
* <math>D\in \mathbb{R}^{n\times n}</math> –– симметрическая матрица дистанций объектов, где <math>D=(d_{ij}), i \in o, j \in o</math>

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

* <math>m = \{m_1,\dots,m_k\}\subset o</math> –– множество индексов объектов, принятых в качестве медоидов

Принадлежность объекта к определенному кластеру определяется как индекс ближайшего к нему медоида:
:<math>g_m(i)=\arg \min_{m_j\in m} d_{im_j}</math>.

Основная задача состоит в выборе такого множества индексов медоидов <math>m</math>, наилучшим образом минимизирующего функционал:
:<math>F_o(m) = \sum_{j \in o} d_{jg_m(j)}</math>.

Введем обозначения:

* <math>D_j = d_{jg_m(j)}</math> –– индекс первого по близости к j медоида
* <math>E_j = d_{jg_{m \backslash g_m(j)}(j)}</math> –– индекс второго по близости к j медоида

Решение задачи состоит из следующих шагов:

1. Шаг ''BUILD''

1.1. Выбор первого медоида
:<math>m=\{ \arg \min_{i \in o} \sum_{j \in o} d_{ij} \}</math>

1.2 Последовательный выбор оставшихся медоидов до тех пор, пока <math>\left\vert{m}\right\vert \neq k</math>
:<math>m = m \cup \{ \arg \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0) \}</math>

2. Шаг ''SWAP''

2.1. Производится перебор всех возможных пар медоид-немедоид <math>(i, h): i \in m, h \in o \backslash m</math>, для каждой из которых рассчитывается стоимость смены текущей конфигурации <math>T_m(i,h)</math>. При смене конфигурации множество медоидов изменяется <math>m = m \cup \{h\} \backslash \{i\}</math>.
:<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>, где <math>C_{jih}</math> –– вклад объекта <math>j</math> в перестановку медоида <math>i</math> и не медоида <math>h</math>.
При этом <math>C_{jih}</math> рассчитывается по-разному в зависимости от положения <math>j</math> относительно <math>i</math> и <math>h</math> (<math>j</math> дальше от <math>i</math> и от <math>h</math>, чем от своего ближайшего медоида; <math>i</math> оказался ближайшим медоидом <math>j</math>; <math>j</math> оказался дальше от <math>i</math>, но ближе к <math>h</math>, чем к своему медоиду).
:<math>C_{jih} = \left\{\begin{matrix}
0, & d_{ji} > D_j, d_{jh} > D_j \\
d_{jh} - d_{ji}, & d_{ji} = D_j, d_{jh} < E_j \\
E_j - D_j, & d_{ji} = D_j, d_{jh} \geqslant E_j \\
d_{jh} - D_j, & d_{ji} > D_j, d_{jh} < D_j
\end{matrix}\right.</math>
Среди всех пар находится такая пара <math>(i_s, h_s)</math>, что <math>T_m(i_s, h_s)</math> минимально.

2.2 В случае, если <math>T_m(i_s, h_s) \geq 0</math>, смена конфигурации медоидов не производится и решение задачи окончено. Иначе производится смена конфигурации и повторяется шаг 2.1.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма на этапе ''BUILD'' состоит последовательного выбора такого объекта из числа немедоидов, добавление которого к множеству медоидов максимизирует следующую функцию:

<math>F_{m} = \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0)</math>

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

Вычислительное ядро алгоритма на этапе ''SWAP'' состоит в расчете функции минимизации стоимости изменения конфигурации <math>T_m(i, h)</math> при замене медоида <math>i</math> на немедоид <math>h</math> в текущей конфигурации для всех возможных <math>(i, h): i \in m, h \in o \backslash m</math>:

<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>.

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

1. Макрооперация "Выбор следующего медоида"
:<math>m = m \cup \{ \arg \max_{i \in o \backslash m} \sum_{j \in o \backslash \{m \cup i\} } \max (D_j - d_{ji}, 0) \}</math>

2. Макрооперация "Вычисление стоимости смены текущей конфигурации"
:<math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih}</math>

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

1. Фаза ''BUILD''

На данном шаге осуществляется выбор первого медоида. Далее осуществляется макрооперация "Выбор следующего медоида" <math>(k - 1)</math> раз.

2. Фаза ''SWAP''

На данном шаге для всех возможных комбинаций медоид-немедоид осуществляется макрооперация "Вычисление стоимости смены текущей конфигурации". Данная операция производится <math>k(n-k)</math> раз для каждой итерации. Среди всех комбинаций выбирается та замена, стоимость которой максимальна.

3. ''Критерий останова''

:<math>T_m(i, h) < 0</math>

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

''Псевдокод алгоритма'':

'''Вход''': Объем входных данных: <math>n\times n + 2</math>. Матрица дистанций D (<math>n\times n</math> вещественных чисел); количество кластеров <math>k \in \mathbb{Z}</math>; максимальное количество итераций алгоритма <math>maxIter \in \mathbb{Z}</math>
'''Выход''': Объем выходных данных: <math>k</math>. Множество индексов медоидов <math>m = \{m_1, \dots, m_k\} \subset \mathbb{Z}</math>
1 # Фаза BUILD
2 Выбор стартового объекта в качестве начального медоида: m = {первый медоид}
3 Пока |m| != k:
4 Выбор следующего медоида i_m
5 Добавление найденного медоида в множество: m = m + {i_m}
6 # Фаза SWAP
7 Пока (maxIter--):
8 Лучшая стоимость замены: Tbest = MAXINT
9 Кандидаты на замену: (i_s, h_s) = (-1, -1)
10 Для всех i из множества медоидов:
11 Для всех j из множества немедоидов:
12 Расчет стоимости замены Tm(i,h)
13 Если Tm(i, h) < Tbest:
14 Tbest = Tm(i, j)
15 Запомнить найденные кандидаты: (i_s, j_s) = (i, h)
16 Если Tbest >= 0:
17 Выход
18 Иначе:
19 m = m + {h} - {i}

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

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

Для осуществления шага ''BUILD'' потребуется:

* <math>n^2</math> операций сложения и <math>n</math> операций сравнения для выбора начального медоида;
* <math>\sum_{l=1}^{k-1} 2(n-l) \cdot (n-l-1)=\frac{2}{3}(k-1)(k^2 - 3kn + k + 3(n-1)n)</math> операций сложения и вычитания для всех итераций выбора медоидов;
* <math>\sum_{l=1}^{k-1} n-l = \frac{1}{2}(k-1)(2n-k)</math> операций сравнения для всех итераций выбора медоидов.

Таким образом, последовательная сложность шага ''BUILD'' оценивается как <math>O(kn^2)</math>.

Для осуществления каждого шага ''SWAP'' потребуется:

* <math>2k(n-k)(n-k-1)</math> операций вычитания и сложения;
* <math>k(n-k)</math> операций сравнения;

Таким образом, последовательная сложность каждого шага ''SWAP'' оценивается как <math>O(kn^2)</math>.
Заранее число итераций шага ''SWAP'' неизвестно, поэтому принимаем его равным <math>T</math>. Отсюда, общая последовательная сложность алгоритма PAM оценивается как <math>O(Tkn^2)</math>.

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

=== Информационный граф шага BUILD ===
На рис.1 показана информационная структура шага BUILD алгоритма PAM на некотором шаге.

[[file:Pam_build.png|thumb|center|553px|Рис.1. Информационная структура шага BUILD алгоритма PAM на шаге <math>t</math>]]

''Операции'':
* <math>sum_{o,m_t}(i) = \sum_{j \in o \backslash \{m \cup i\}} \max (D_j, d_{ji})</math> –– оценка конфигурации при внесении <math>i</math> в множество индексов медоидов <math>m</math> с множеством объектов <math>o</math>;
* <math>\arg \max</math> –– индекс объекта, дающего наибольшую оценку конфигурации при его внесении в множество индексов медоидов <math>m</math>;
* <math>update(m)</math> –– операция добавления индекса объекта в множество индексов медоидов <math>m</math>.

=== Информационный граф шага SWAP ===
На рис.2 показана информационная структура шага SWAP алгоритма PAM на некотором шаге.

[[file:Pam_swap.png|thumb|center|553px|Рис.2. Информационная структура шага SWAP алгоритма PAM на шаге <math>t</math>]]

''Операции'':
* <math>T_m(i, h) = \sum_{j \in o \backslash \{m \cup h\}} C_{jih} </math> –– стоимость смены конфигурации при замене немедоида <math>h</math> медоидом <math>i</math> в текущей конфигурации <math>m</math>;
* <math>\arg \min</math> –– пара <math>(i, h)</math> (медоид-немедоид), замена которой в текущей конфигурации <math>m</math> дает наименьшую стоимость смены;
* <math>swap</math> –– операция замены медоида <math>i</math> на немедоид <math>h</math> в текущей конфигурации <math>m</math>, если стоимость смены отрицательна.

== Ресурс параллелизма алгоритма ==
Для осуществления шага ''BUILD'' потребуется:

* <math>n</math> параллельных операций сложения и <math>n</math> последовательных операций сравнения для выбора начального медоида;
* <math>\sum_{l=1}^{k-1} 2(n-l) = (k-1)(2n-k)</math> параллельных операций сложения и вычитания для всех итераций выбора медоидов;
* <math>\sum_{l=1}^{k-1} n-l = \frac{1}{2}(k-1)(2n-k)</math> последовательных операций сравнения для всех итераций выбора медоидов.

Таким образом, параллельная сложность шага ''BUILD'' оценивается как <math>O(kn)</math>.

Для осуществления каждого шага ''SWAP'' потребуется:

* <math>k(n-k) </math> параллельных операций вычитания и сложения;
* <math>k(n-k)</math> последовательных операций сравнения.

Таким образом, параллельная сложность каждого шага ''SWAP'' оценивается как <math>O(kn)</math>.
Заранее число итераций шага ''SWAP'' неизвестно, поэтому принимаем его равным <math>T</math>. Отсюда, общая параллельная сложность алгоритма PAM оценивается как <math>O(Tkn)</math>.

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

''Входные данные'':
* Массив <math>V</math> из <math>\frac{n(n-1)}{2}</math> вещественных чисел, определяющий набор дистанций между всеми парами объектов (сжатая матрица дистанций). Симметрическая матрица дистанций <math>D\in \mathbb{R}^{n\times n}</math> восстанавливается из этого массива однозначным образом (для восстановления необходимо знать число объектов <math>n</math>):
:<math>D(i, j)=\left\{\begin{matrix}
V[ni - \frac{i(i + 1)}{2} + (j - i - 1)], & i < j\\
V[nj - \frac{j(j + 1)}{2} + (i - j - 1)], & i > j \\
0, & i = j
\end{matrix}\right.</math>

* Целое число кластеров <math>k</math>, на которое необходимо разбить множество объектов.

''Выходные данные'':
* Множество <math>m</math>, состоящее из <math>k</math> индексов объектов, принятых в качестве медоидов. Индекс кластера, которому принадлежит объект с индексом <math>i</math> можно восстановить с использованием функции <math>g_m(i)=\arg \min_{m_j\in m} d_{im_j}</math>.

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

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

2. ''Вычислительная мощность'' последовательного алгоритма, как отношение числа операций к суммарному объему входных и выходных данных: <math> O(Tk) </math>.

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

4. Алгоритм является ''не детерминированным'', так как не детерминирован выбор набора медоидов, на которых достигается наилучшая конфигурация.

5. Имеет высокую вычислительную сложность (квадратичную) ввиду необходимости полного перебора, поэтому неэффективно работает на больших наборах данных.

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

7. Устойчив к выбросам данных (за счет рассмотрения медоидов).

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

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

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

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

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

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

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

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

1. Последовательные реализации

* В [https://www.mathworks.com/help/stats/kmedoids.html?requestedDomain=www.mathworks.com#namevaluepairs MATLAB] ([https://ru.wikipedia.org/wiki/Коммерческое_программное_обеспечение Commercial software])
* [http://elki.dbs.ifi.lmu.de/browser/elki/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java ELKI] на языке JAVA (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_Affero_General_Public_License AGPL]))
* В пакете [https://cran.r-project.org/package=cluster Cluster] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_General_Public_License#GPL_v1 GPL]))
* В пакете [https://cran.r-project.org/package=ClusterR ClusterR] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/Лицензия_MIT MIT]))

2. Параллельные реализации

* В пакете [https://cran.r-project.org/package=sprint SPRINT] на языке R (Свободное распространение ([https://ru.wikipedia.org/wiki/GNU_General_Public_License#GPL_v1 GPL]))

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

[[en:Description of algorithm properties and structure]]

Участник:Юлия Жосан/Разбиение вершин графа на равные по мощности блоки методом рекурсивной координатной бисекции

2016-11-01T15:43:22Z

Lineprinter: Lineprinter переименовал страницу Юлия Жосан/Разбиение вершин графа на равные по мощности блоки методом рекурсивной координатной бисекции…

Автор: [[User:Юлия Жосан|Юлия Жосан]]
== Свойства и структура алгоритмов ==
=== Общее описание алгоритма ===
----
'''Декомпозиция графа''' - это задача его разбиения на непересекающиеся подмножества доменов, для их последующей параллельной обработки группой процессоров. Основная сложность использования параллельных методов состоит в поиске оптимальной декомпозиции, которая дает сбалансированное распределение доменов по процессорам. Выделяют два основных свойства оптимальной декомпозиции, которые должны выполняться одновременно:
*минимизация максимального веса исходящих из домена ребер
*равномерное распределение по доменам суммарного веса узлов/ребер

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

'''Основные этапы работы алгоритма:'''
#Выбор направления, вдоль которого будут упорядочиваться вершины домена
#Упорядочивание вершин вдоль выбранного в п.1 направления
#Вычисление номера m первой вершины второго домена
#Формирование двух новых доменов, первый из которых включает вершины от первой до m-1 входящего домена, а второй включает вершины с m до последней вершины входящего домена
#Запуск алгоритма для полученных в п.4 доменов

Выделяют следующие '''достоинства''' данного алгоритма:
*высокая скорость работы
*низкий уровень дисбаланса распределения вершин между доменами
*экономичность по памяти
===Математическое описание алгоритма===
----
Пусть на '''вход''' алгоритму подаются следующие данные:
*неориентированный граф <math>G=(V, E)</math>, где <math>V</math> - множество вершин, <math>E</math> - множество ребер
*Требуемое число доменов <math>p</math>

На '''выходе''' алгоритма требуется получить множество доменов <math>\{S_{p}\}</math>.Это множество <math>p</math> непересекающихся подмножеств <math>\{V_{i}\}</math>:
<br /> <math>V=\bigcup\limits_{i=1}^{p} V_{i}</math>, <math>V_{i}\cap V_{j}=\emptyset</math> для <math>i\not=j</math>
при котором минимизируются следующие функционалы:
*суммарный вес вершин в домене: <math>\vert S_{p}\vert=\sum\limits_{i=1}^{p} \vert v_{i} \vert\rightarrow min</math>
*суммарный вес разрезанных ребер:<math>\sum\limits_{ij} \vert e_{ij} \vert\rightarrow min , v_{i}\in S_{l}, v_{j}\in S_{r}, S_{l}\cap S_{r}=\emptyset</math>

Опишем подробнее '''схему работу''' рекурсивного алгоритма:
#Выбор оси, вдоль которой будет осуществляться сортировка. Для этого вычисляется величина <math>l_{k}=max\left( v_{i}^{k}\right)-min\left(v_{i}^{k}\right) , v_{i}^{k}\in V , k </math> - координатная ось, и выбирается ее максимальное значение.
#Сортировка множества вершин <math>V</math> по выбранной в п.1 координате по возрастанию номеров коодинат вершин
#Вычисляется номер вершины, по которой пойдет разбиение множества: <math>m=(iend-istart+1)*\frac{\frac{p+1}{2}}{p}</math>, где <math>iend, istart</math> - номер первой вершины в множестве и номер последней вершины в множестве соответственно
#Множество вершин делится на две части: <math>V_{l}=|v_{l}|, l=istart..m ,V_{r}=|v_{r}|, r=m+1..iend </math>
#Алгоритм запускается для <math>V_{l}</math> и <math>V_{r}</math>
#Алгоритм останавливается на итерации, для которой <math>|V_{l}|=1 , |V_{r}|=1</math>
=== Вычислительное ядро алгоритма===
----
Вычислительное ядро алгоритма составляют:
*сортировка массива координат вершин <math>V</math> (могут применяться различные виды сортировок)
*вычисление величины <math>l_{k}</math> - координатной оси
*вычисление величины <math>m</math> - точки раздела множества

=== Макроструктура алгоритма===
----
Основной составляющей метода является повторяющиеся сортировки множества координат вершин <math>V</math> на каждом рекурсивном шаге. Всего таких шагов <math>p-1</math>.

=== Схема реализации последовательного алгоритма===
----
Представим последовательную реализацию метода рекурсивной координатной бисекции с помощью псевдокода:
<br/><math>BisectCoordRec\{V, iend, istart , p\}</math>
<br/>{
<br/>'''Шаг 1:''' <math>l_{k}=argmax{max\left( v_{i}^{k}\right)-min\left(v_{i}^{k}\right)} </math> - //определение оси для сортировки
<br/>'''Шаг 2:''' <math>Sort(V, iend, istart ,l_{k})</math>- //сортировка вершин по выбранной координате
<br/>'''Шаг 3:''' <math>m=(iend-istart+1)*\frac{\frac{p+1}{2}}{p}</math> - //поиск точки для разделения множества вершин
<br/>'''Шаг 4:''' <math>Bisect\left(V,(iend-istart) , V_{l}, \frac{p+1}{2}, V_{r}, \frac{\frac{(iend-istart)*(p+1)}{2}}{p}\right)</math>- //разделение массива вершин на два
<br/>'''Шаг 5:''' <math>if |V_{l}|>1 : BisectCoordRec\{V_{l},\frac{(iend-istart)*\frac{p+1}{2}}{p} , \frac{p+1}{2}, p\}</math>
<br/>'''Шаг 6:''' <math>if |V_{r}|>1 : BisectCoordRec\{V_{r}, (iend-istart) - \frac{(iend-istart)*\frac{p+1}{2}}{p} , p - \frac{p+1}{2}, p\}</math>
<br/>}

=== Последовательная сложность алгоритма===
----
Пусть в графе <math>G</math> содержится <math>|V|=n</math> вершин.
*Для определения координат <math>iend, istart</math> требуется <math>O(n)</math> попарных сравнений
*Для сортировки массива вершин по координате требуется <math>O(nlog_{2}n)</math> попарных сравнений

Так как всего осуществляется <math>p-1</math> шагов рекурсии, глубина ее составляет <math>-log_{2}p+1</math>
Значит можно определить сложность алгоритма следующим образом:
<math>O(nlog_{2}nlog_{2}p)</math>
=== Информационный граф===
----

[[File: bisec_gr.jpg]]
<br/>

=== Ресурс параллелизма алгоритма===
----
Структура параллельного алгоритма:
#Подготовительный этап:
#*определение числа и объема требуемых доменов по процессорам
#**Пусть имеется граф с n вершинами, он распределяется по k доменам. Тогда глубина рекурсии - <math>log_{2}k</math>, что равняется числу ярусов.
#Разделение доменов по процессорам:
#*вызов рекурсивной покоординатной бисекции по процессорам:
#**сортировка вершин графа (на i-м ярусе выполняется <math>2^i</math> операций)
#**разделение на два подграфа для разделения по доменам
#Параллельные вызовы алгоритма для каждого процессора
#*вызов локальной координатной бисекции по доменам

Пусть сложность сортировки равна <math>O(n\log_2{n})</math>.
<br/>Тогда сложность алгоритма можно представить в следующем виде:
<math>O(\sum\limits_{i=0}^{log_2{k}}\frac{n}{2^i}\log_2{\frac{n}{2^i}})=
O(\sum\limits_{i=0}^{log_2{k}}(n\frac{(log_2{n}-i)}{2^i}))=
O(n(\sum\limits_{i=0}^{log_2{k}}(\frac{log_2{n}}{2^i})-\sum\limits_{i=0}^{log_2{k}}(\frac{i}{2^i})))=
O(n\log_2{n})-O(n)=O(n\log_2{n})</math>.

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

----

'''Вход алгоритма:'''
*неориентированный граф <math>G=(V, E)</math>, где <math>V</math> - множество вершин, <math>E</math> - множество ребер
*Требуемое число доменов <math>p</math>

'''Выход алгоритма:'''
*<math>p</math> доменов <math>\{S_{p}\}</math>, задающих декомпозицию графа
=== Свойства алгоритма===
----
*Низкий уровень дисбаланса распределения вершин между доменами. Т.е. количество вершин в доменах примерно одинаковое.
*Алгоритм детерминирован в случае использования устойчивой сортировки вершин.
*Алгоритм достаточно прост в реализации.

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

----
'''Параллельные''' реализации:
*[http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview ParMETIS]
*JOSTLE
*[https://www.labri.fr/perso/pelegrin/scotch/ PT-SCOTCH]
*ZOLTAN

'''Последовательные''' реализации:
*[http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS]
*JOSTLE
*[https://www.labri.fr/perso/pelegrin/scotch/ SCOTCH]
*CHACO
*PARTY

== Литература==
----
[1] Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/
<br/>[2] Головченко Е.Н. Декомпозиция расчетных сеток для решения задач механики сплошных сред на высокопроиводительных вычислительных системах. Дисс ... канд. ф.-м.наук. Институт прикладной математики им. М. В. Келдыша РАН, г. Москва URL: http://keldysh.ru/council/3/D00202403/golovchenko_diss.pdf

Участник:Fokina/Рекурсивная координатная бисекция

2016-11-01T15:42:41Z

Lineprinter: Lineprinter переименовал страницу Рекурсивная координатная бисекция в Участник:Fokina/Рекурсивная координатная бисекция без оставления пе…

{{Assignment}}
{{level-m}}
{{algorithm
| name = Рекурсивная координатная бисекция
| serial_complexity = <math>O((k-1)*n*log(n))</math>
| pf_height = <math>O(log_2 k)</math>
| pf_width = <math>O(k/2)</math>
| input_data = <math>n*m</math>
| output_data = <math>n*m</math>
}}
Автор: [[U:Fokina|Фокина Н.Ю.]]
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Метод рекурсивной координатной бисекции был предложен Бергером (M. Berger) и Бохари (S. Bokhari) в 1987 году<ref>M. Berger and S. Bokhari. "A partitioning strategy for nonuniform problems on multiprocessors." IEEE Trans. Computers, C-36 (1987) 570-580.</ref> для решения задачи статической баланисировки загрузки. В основе метода лежит идея равномерного разбиения точек в пространстве с помощью гиперплоскостей.

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

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

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

=== Математическое описание алгоритма ===
В начале работы имеется домен -- множество вершин графа <math>G</math>, заданных в виде векторов координат <math>(v_1,..,v_m)</math>, где <math>m</math> -- размерность пространства.
На каждой итерации осуществляется сортировка вершин, входящих в домен, вдоль оси, по которой он имеет наибольшую протяженность. Затем домен разделяется на поддомены путем разбиения: первые <math>n/2</math> или <math>n*k/2</math> из отсортированного ранее домена относят к первому поддомену, оставшиеся -- к второму. Полученные поддомены также являются доменами и передаются в качестве входных данных на следующую итерацию до тек пор, пока общее количество поддоменов не достигнет необходимого числа <math>k</math>.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на сортировку данных на каждой итерации. В связи с этим целесообразно использовать алгоритмы сортировки, имеющие наименьшую среднюю сложность и показавшие высокую эффективность на практике. В последовательном случае такой сортировкой может являться комбинация из пирамидальной сортировки и сортировки слиянием, имеющая сложность <math>O(n*\log(n))</math>. Параллельная версия данной сортировки также эффективна и имеет сложность <math>O(\frac{n}{p} \big\lbrack \log(\frac{n}{p})+\frac{\lceil \log (p) \rceil^2}{2} \big\rbrack)</math><ref>Якобовский М.В. Параллельные алгоритмы сортировки больших объемов данных // Фундаментальные физико-математические проблемы и моделирование технико-технологических систем: Сб. науч. тр. : Янус-К, 2004, c. 235-249.</ref>. Еще больший прирост производительности может дать битоническая сортировка, сложность которой оценивается как <math>O(\log^2(n))</math>.

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

На каждом этапе рекурсивной координатной бисекции происходит следующее:
# Определяются границы наименьшего параллелепипеда, охватывающего все вершины, которые делятся на данном этапе. Вычисляются максимумы по каждой из координат. Определяется координата <math>j</math>, вдоль которой параллелепипед имеет наибольшую протяженность.
# Выполняется сортировка вершин по координате <math>j</math>.
# Создается два новых поддомена. Первая половина вершин из отсортированного домена помещается в первый поддомен, все последующие -- в второй.

Стоит отметить, что разбиение целесообразно производить одновременно по нескольким координатам. Для этого вершины сортируются сначала по одной координате, потом внутри нее по следующей координате в циклическом порядке и т.д., что позволяет обрабатывать ситуации наличия нескольких узлов с одним значением координаты. В результате медиана проводится точно, и в разбиении на равные домены числа вершин в доменах отличаются не больше чем на единицу<ref>Головченко, Е. Н., Якобовский, М. В. (2015). Пакет параллельной декомпозиции больших сеток GridSpiderPar. вычислительные методы и программирование, 16, 507.</ref>.

=== Схема реализации последовательного алгоритма ===
Реализация метода рекурсивной бисекции на языке C в общем виде изображена на следующем рисунке:
<source lang="c">
void
recursive_bisect(struct Vertex *graph, int n, int k) {
int k1, k2;
int n1, n2;
struct Vertex * subgraph1;
struct Vertex * subgraph2;

k1 = (k + 1) / 2;
k2 = k - k1;
n1 = n * k1 / k;
n2 = n - n1;

bisect(graph, n, subgraph1, n1, subgraph2, n2);

if (k1 > 1) recursive_bisect(subgraph1, n1, k1);
if (k2 > 1) recursive_bisect(subgraph2, n2, k2);

return;
}</source>
В качестве входных параметров функция принимает массив вершин, содержащихся в текущем домене (<code>graph</code>), числа <code>n</code> -- количество вершин, <code>k</code> -- количество поддоменов, на который требуется разбить данный домен.

В теле функции вычисляется отношение между количеством поддоменов, на которые будут впоследствии разбиты полученные на текущей итерации поддомены (<code>k1</code> и <code>k2</code>), и размеры поддоменов, которые будут получены на данной итерации (<code>n1</code> и <code>n2</code>). С помощью вызова функции <code>bisect</code> осуществляется непосредственно разбиение на два поддомена. Затем функция <code>recursive_bisect</code> рекурсивно вызывается на полученных поддоменах до тех пор, пока остается необходимость в дальнейшем их разбиении.

Выбор конкретного алгоритма зависит от использованной функции <code>bisect</code>, которой осуществляется разбиение вершин на два подграфа на каждом из этапов. В случае координатной бисекции она имеет следующий вид:
<source lang="c">
void
coord_bisect(struct Vertex *graph, int n, struct Vertex *subgraph1, int n1, struct Vertex *subgraph2, int n2) {
int axis;

/* Calculate direction in which the initial graph is most elongated. */
axis = calculate_max_distance(graph, n);

/* Sort vertices along the selected axis. */
sort(graph, n, axis);

/* Create subgraphs. */
subgraph1 = create_subgraph(graph, 0, n1);
subgraph2 = create_subgraph(graph, n1, n);

return;
}</source>
Входными параметрами функции являются массив вершин в домене, его размер, а также размеры полученных в результате разбиения поддоменов. Выходными параметрами являются массивы вершин, входящих в полученные поддомены. Следует отметить, что на вход достаточно передавать размер лишь одного из поддоменов, например, первого, поскольку размер второго явно из него следует, т.к. <math>n1 + n2 == n</math>. В данном примере оба размера передаются для наглядности и единообразия.

В процессе работы функции с помощью вызова функции <code>calculate_max_distance</code> выбирается координатная ось, вдоль которой сетка имеет наибольшую протяженность. Затем вершины сортируются вдоль этой оси, и создаются два поддомена: в первый входят вершины с индексами <code>[0..n1)</code> в отсортированном массиве, в второй -- <code>[n1..n)</code>, где <code>n1</code> равно <math>\frac{n*\frac{(k+1)}{2}}{2}</math>.

=== Последовательная сложность алгоритма ===
В течение каждого этапа выполняются следующие действия:
# Определение диаметра графа по каждой из координат -- <math>m*O(n)</math>, где <math>m</math> -- размерность пространства, <math>n</math> -- количество вершин. Поскольку величина <math>m</math>, как правило, очень мала, ей можно пренебречь, оставив в качестве оценки сложности данного действия <math>O(n)</math>.
# Поиск максимального расстояния -- осуществляется за <math>O(m)</math>, также пренебрежимо мало.
# Сортировка. Наиболее эффективным алгоритмом последовательной сортировки является комбинация сортировки слиянием и пирамидальной сортировки <ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2</ref>. Сложность как пирамидальной сортировки, так и сортировки слиянием оценивается как <math>O(nlog_2(n))</math>.
# Разбиение домена на поддомены осуществляется за <math>O(1)</math>.
Исходя из этого, общая сложность каждой итерации оценивается сверху как <math>O(nlog_2(n))</math>, а их количество составляет <math>(k - 1)</math>. Таким образом, последовательная сложность метода -- <math>O((k-1) *n*log(n))</math>.

=== Информационный граф ===
На рисунке 1 приведена общая схема работы метода. Входными данными является граф -- массив вершин, заданных в виде векторов координат. Выходными данными является множество массивов, элементами которых являются исходные вершины.
[[File:Rcb1.png|320px|thumb|center|Рис. 1. Общая схема рекурсивной координатной бисекции]]
На рисунке 2 изображен информационный граф метода при распределении домена из 4 вершин, заданных в двумерном пространстве, на 2 поддомена. Входными данными являются вектора <code>A1</code>-<code>A4</code>, которые могут содержаться либо в исходном домене, либо в поддомене, полученном на предыдущей итерации. Выходные данные -- непересекающиеся множества векторов <code>B1</code> и <code>B2</code>. В них содержатся вектора <code>A1</code>-<code>A4</code>. Вершины с меткой <code>CD</code> обозначают операцию вычисления диаметра домена (т.е. наибольшего расстояния между содержащимися в домене вершинами) по координатам <math>x</math> и <math>y</math> соответственно. Вершина <code>MAX</code> обозначает нахождение максимума, <code>SORT</code> -- сортировку, <code>SPLIT</code> -- разбиение домена на два поддомена равного размера.
[[File:Rcb2.png|799px|thumb|center|Рис. 2. Информационный граф для одной итерации]]

=== Ресурс параллелизма алгоритма ===
При разбиении графа на <math>k</math> подграфов глубина рекурсии составляет <math>\lceil log_2 k \rceil</math>, а на каждом <math>i</math> шаге решается до <math>2^i</math> подзадач. Поскольку подзадачи, возникающие на каждом шаге рекурсии, не имеют информационных зависимостей друг между другом, их решение можно распараллелить, получив таким образом некоторый прирост производительности. Исходя из того, что сложность этих подзадач примерно одинакова, можно считать, что
их решение занимает примерно одинаковое время <math>t</math> и не зависит от яруса, на котором решается конкретная подзадача. При разбиении графа на <math>k</math> подграфов требуется решить <math>k-1</math> подзадач. Время их последовательного выполнения составляет <math>T_1 = t*(k-1)</math>. Пусть доступно бесконечное число одинаковых процессоров. При распараллеливании затраченное время сокращается до <math>T_\infty(k) = t * \lceil log_2 k \rceil</math>. Таким образом, предельное ускорение от распараллеливания рекурсивной бисекции составляет <math>S(k) = \frac{T_1(k)}{T_\infty(k)} = \frac{k-1}{\lceil log_2 k \rceil}</math>.

Если количество доступных процессоров ограничено некоторым числом <math>p</math>, то имеет место следующее соотношение:
<math>S(k, p) = \frac{p * \lfloor log_2 k \rfloor}{2*p - 2 + \lfloor log_2 k \rfloor - \lceil log_2 p \rceil}</math>.

=== Входные и выходные данные алгоритма ===
Метод рекурсивной координатной бисекции работает над графами, часто -- сеточными. Поскольку метод не учитывает связи между вершинами, входные данные удобно задавать в виде массива координат в <math>n</math>-мерном прострастве, т.е. векторов размерности <math>n</math>. Как правило, в прикладных задачах <math>n</math> составляет 2 или 3, т.е. заданы координаты на плоскости или в пространстве.

'''Входные данные алгоритма:''' Исходный граф <math>G</math>, натуральное число <math> k \in \N </math> -- количество подграфов, на которое нужно осуществить разбиение.

'''Объем входных данных:''' <math>n*m</math>, где <math>n</math> -- количество векторов, <math>m</math> -- размерность пространства.

'''Выходные данные алгоритма:''' Множество <math>G_1 .. G_k</math> подграфов исходного графа <math>G</math>.

'''Объем выходных данных:''' <math>n*m</math>, где <math>n</math> -- количество векторов, <math>m</math> -- размерность пространства.

=== Свойства алгоритма ===
Метод рекурсивной координатной бисекции является устойчивым и детерминированным. Его вычислительная мощность пропорциональна <math>log(n)</math>. Вычислительная сложность определяется, главным образом, использованным алгоритмом сортировки и составляет <math>O((k-1)*n*log(n))</math> в последовательном и <math>O(\log(k)*\log^2(n))</math> в параллельном случае.

Можно также отметить следующие особенности метода:
* Использование параллельного алгоритма рекурсивной координатной бисекции целесообразно при разбиении на большое число подграфов.

* Наибольшее ускорение достигается при разбиении на число подграфов, являющееся степенью двойки.

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

* Небольшие накладные расходы, возникающие при обращении процессора к полной информации о разбиении.

* Отсутствие явного контроля над накладными расходами на передачу данных.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Наиболее широко в настоящее время применяется параллельный алгоритм рекурсивной координатной бисекции, реализованный в пакете ZOLTAN (Zoltan2) [https://trilinos.org/docs/dev/packages/zoltan2/doc/html/rcbPage.html].

Метод рекурсивной координатной бисекции сеток реализован в пакете GridSpiderPar [http://lira.imamod.ru/FondProgramm/Decomposition/].
Использованный в нем алгоритм отличается от аналогичного алгоритма в пакете ZOLTAN тем, что в нем секущая плоскость (медиана) при необходимости разрезается по нескольким координатам. Это позволяет обрабатывать ситуации наличия на одной плоскости множества узлов с одинаковым значением координаты, что характерно для регулярных сеток. В пакете ZOLTAN вершины из медианы распределяются по областям произвольным образом, что увеличивает число разрезанных ребер.

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

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

Участник:Fokina/Рекурсивная координатная бисекция

2016-11-01T15:42:18Z

Lineprinter:

Алговики:Общий форум

2016-11-01T15:24:14Z

Lineprinter:

{{project internals nav}}
== Обустраивание проекта ==
Админы, скопируйте пожалуйста [https://ru.wikipedia.org/wiki/MediaWiki:Edittools] в [[MediaWiki:Edittools]] - удобнее работать с текстом будет. [[Участник:AntonChupin|AntonChupin]] ([[Обсуждение участника:AntonChupin|обсуждение]]) 14:03, 8 июля 2016 (MSK)
: Сделано. — [[S:Contributions/Lineprinter|lineprinter]] 11:13, 1 ноября 2016 (MSK)

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

{{:Список описаний алгоритмов}}

== Словарик ==

{| class="wikitable"
!Русский
!English
|-
|алгоритм
|algorithm
|-
|вершина (графа)
|vertex
|-
|входные/выходные данные
|input/output data
|-
|вычислительная мощность
|computational power
|-
|вычислительное ядро (алгоритма)
|computational kernel
|-
|вычислительное ядро (процессора)
|computational core
|-
|вычислительный узел
|computational node
|-
|граф алгоритма
|algorithm graph
|-
|дуга (графа)
|edge
|-
|избыточные вычисления
|redundant computation
|-
|информационный граф
|information graph
|-
|каноническая ярусно-параллельная форма
|canonical parallel form
|-
|кэш-строка (строка кэш-памяти)
|cache line
|-
|локальность
|locality
|-
|макроструктура
|macro structure
|-
|масштабируемость
|scalability
|-
|метод сдваивания
|pairwise summation
|-
|накладные расходы
|overhead
|-
|параллельная сложность
|parallel complexity
|-
|последовательный (алгоритм, программа)
|serial (sequential)
|-
|последовательная сложность
|serial complexity
|-
|производительность
|performance
|-
|реализация
|implementation
|-
|ресурс параллелизма
|parallelism resource
|-
|сопроцессор
|co-processor
|-
|ускорение
|speedup
|-
|ускоритель
|accelerator
|-
|функциональное устройство
|functional unit
|-
|цикл (программы)
|loop
|-
|эффективность
|efficiency
|-
|ярус
|layer
|-
|ярусно-параллельная форма
|parallel form
|}

На перевод

2016-11-01T15:23:50Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии ASA

[[Приложение 1]]
[[Приложение 2]]
[[Приложение 3]]
[[Приложение 4]]
[[Приложение 5]]
[[Приложение 6]]
[[Приложение 7]]
[[Приложение 8]]
[[Приложение 9]]
[[Приложение 10]]

Teplov sandbox

2016-11-01T15:23:29Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Teplov

{| class="simple" border="1"
||Оценка по числу процессоров
|Программа
|-
||-0,061256
|Linpack Benchmark
|-
||-0,0436
|Перемножение матриц
|-
||-0,01517
|Умножение матрицы на вектор
|-
||-0,00059
|Метод Холецкого
|-
||-0,0001
|Метод Гаусса Прямой ход
|-
||-3,06E-06
|Схема сдваивания
|-
||-9,43E-07
|Суммирование элементов вектора
|-
||0,00414
|Скалярное произведение векторов
|-
|}

{| class="simple" border="1"
||Оценка по размеру задачи
|Программа
|-
||-0,0255
|Перемножение матриц
|-
||-0,01385
|Скалярное произведение векторов
|-
||-0,00674
|Метод Гаусса прямой ход
|-
||-0,0014
|Умножение матрицы на вектор
|-
||6,43E-09
|Схема сдваивания
|-
||1,88E-06
|Суммирование элементов вектора
|-
||0,010134
|Linpack Benchmark
|-
||0,06017
|Метод Холецкого
|-
|}

{| class="simple" border="1"
||Общая оценка
|Программа
|-
||-0,00097
|Перемножение матриц
|-
||-0,00017
|Скалярное произведение векторов
|-
||-0,00015
|Умножение матрицы на вектор
|-
||-6,62E-05
|Метод Гаусса прямой ход
|-
||-1,42E-07
|Суммирование элементов вектора
|-
||-8,05E-08
|Схема сдваивания
|-
||2,84E-05
|Linpack Benchmark
|-
||0,000403
|Метод Холецкого
|-
|}

Sandbox

2016-11-01T15:23:22Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Algoman

<math> \sum \left ( \mathbf{{\widetilde{\gamma \prod \alpha ^{test} }}'} \right )</math>

<math>
\frac{1}{\displaystyle 1+
\frac{1}{\displaystyle 2+
\frac{1}{\displaystyle 3+x}}} +
\frac{1}{1+\frac{1}{2+\frac{1}{3+x}}}
</math>

<source lang="fortran">
C FORTRAN IV WAS ONE OF THE FIRST PROGRAMMING
C LANGUAGES TO SUPPORT SOURCE COMMENTS
WRITE (6,7)
7 FORMAT(13H HELLO, WORLD)
STOP
END
</source>

<source lang="cpp">
int main(int argc, char** argv)
{
return 0;
}
</source>

[[Файл:Example.jpg]]

Algorithm classification

2016-11-01T15:23:10Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии ASA

# <div id="Vector operations">'''Vector operations'''</div>
## ''Pairwise summation''
### {{level|Summing an array by pairwise summation}}
### {{level|Finding partial sums of an array by pairwise summation}}
## {{level|Uniform norm of a vector: Real version, serial-parallel variant}}
## {{level|Dot product: Real version, serial-parallel variant}}
## {{level|Serial-parallel summation method}}
# <div id="Matrix-vector operations">'''Matrix-vector operations'''</div>
## {{level|Dense matrix-vector multiplication}}
# <div id="Matrix operations">'''Matrix operations'''</div>
## {{level|Dense matrix multiplication}}
# <div id="Matrix decompositions">'''Matrix decompositions'''</div>
## ''Triangular decompositions''
### Gaussian elimination (finding the LU decomposition)
#### {{level|Gaussian elimination without pivoting}}
##### LU decomposition via Gaussian elimination
##### Compact scheme for Gaussian elimination and its modifications
###### Compact scheme for Gaussian elimination: Dense matrix
###### {{level|Compact scheme for Gaussian elimination and its modifications: Tridiagonal matrix}}
####### {{level|Compact scheme for Gaussian elimination: Tridiagonal matrix, serial variant}}
####### {{level|Stone doubling algorithm for the LU decomposition of a tridiagonal matrix}}
####### {{level|Serial-parallel algorithm for the LU decomposition of a tridiagonal matrix}}
#### Gaussian elimination with pivoting
##### Gaussian elimination with column pivoting
##### Gaussian elimination with row pivoting
##### Gaussian elimination with diagonal pivoting
##### Gaussian elimination with complete pivoting
### {{level|Cholesky method (finding the symmetric triangular decomposition)}}
#### {{level|Cholesky decomposition (square root method)}}: Basic pointwise real variant, dense symmetric positive definite matrix
### {{level|Available triangular decompositions for matrices of special form}}
## ''Unitary-triangular decompositions''
### {{level|Givens method (rotation method) for the QR-decomposition of a matrix}}
### {{level|Householder method (reflection method) for the QR-decomposition of a matrix}}
## ''Unitary Hessenberg decompositions''
### {{level|Householder method (reflection method) for reducing a matrix to Hessenberg (bidiagonal) form}}
### {{level|Givens method (rotation method) for reducing a matrix to Hessenberg (bidiagonal) form}}
## ''Unitary-diagonal decompositions''
### {{level|Eigenvalue decomposition (finding eigenvalues and eigenvectors)}}
### {{level|Singular value decomposition (finding singular values and singular vectors)}}
# <div id="Solving systems of linear algebraic equations (SLAEs)">'''Solving systems of linear algebraic equations (SLAEs)'''</div>
## Direct methods for solving SLAEs
### {{level|Linpack benchmark}}
### Methods for solving SLAEs of special forms
#### Methods for solving triangular SLAEs
##### {{level|Forward substitution (real version)|Forward substitution}}
##### {{level|Backward substitution (real version)|Backward substitution}}
##### Methods for solving bidiagonal SLAEs
###### {{level|Forward and backward substitution for bidiagonal SLAEs}}
###### {{level|Stone doubling algorithm for solving bidiagonal SLAEs}}
###### {{level|Serial-parallel variant of the backward substitution}}
#### {{level|Methods for solving tridiagonal SLAEs}}
##### Methods based on the conventional LU decomposition
###### {{level|Thomas algorithm}}
####### {{level|Thomas algorithm, pointwise version|Classical monotone elimination algorithm}}
####### {{level|Repeated Thomas algorithm, pointwise version|Thomas algorithm repeated for a new right-hand side: Classical scheme}}
###### {{level|Stone doubling algorithm}}
###### {{level|Serial-parallel method for solving tridiagonal SLAEs based on the LU decomposition and backward substitutions}}
##### Other methods
###### {{level|Reduction method}}
####### {{level|Complete reduction method}}
####### {{level|Reduction method repeated for a new right-hand side}}
###### Two-sided Thomas algorithm
####### {{level|Two-sided Thomas algorithm, pointwise version|Classical two-sided scheme}}
####### {{level|Repeated two-sided Thomas algorithm, pointwise version|Thomas algorithm repeated for a new right-hand side: Two-sided scheme }}
###### {{level|Cyclic reduction}}
####### {{level|Complete cyclic reduction}}
####### {{level|Cyclic reduction repeated for a new right-hand side}}
###### {{level|Bordering method}}
#### Methods for solving block triangular SLAEs
##### {{level|Block forward substitution (real version)|Block forward substitution}}
##### {{level|Block backward substitution (real version))|Block backward substitution}}
##### Methods for solving block bidiagonal SLAEs
###### {{level|Forward and backward substitution for block bidiagonal SLAEs}}
###### {{level|Stone doubling algorithm for solving block bidiagonal SLAEs}}
###### {{level|Serial-parallel variant of the block backward substitution for solving block bidiagonal SLAEs}}
#### {{level|Methods for solving block tridiagonal SLAEs}}
##### Methods based on the conventional LU decomposition
###### {{level|Block Thomas algorithm}}
###### {{level|Serial-parallel method for solving block SLAEs based on the LU decomposition and backward substitutions}}
##### Other methods
###### {{level|Two-sided Thomas algorithm, block variant}}
###### {{level|Block cyclic reduction}}
###### {{level|Block bordering method}}
### {{level|Solving SLAEs with coefficient matrices of special form whose inverses are known}}
## Iterative methods for solving SLAEs
### {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
# <div id="Solving eigenvalue problems">'''Solving eigenvalue problems'''</div>
## {{level|Eigenvalue decomposition (finding eigenvalues and eigenvectors)}}
### {{level|QR algorithm}}
### {{level|Givens method (rotation method) for solving the symmetric eigenvalue problem}}
## {{level|Singular value decomposition (finding singular values and singular vectors)}}
# <div id="Computer performance tests">'''Computer performance tests'''</div>
## {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
## {{level|Linpack benchmark}}
# <div id="Fourier transform">'''Fourier transform'''</div>
## {{level|Fast Fourier transform for powers of two}}
# <div id="Algebra of polynomials">'''Algebra of polynomials'''</div>
## {{level|Horner's rule: Real version, serial variant|Horner's rule}}
# <div id="Numerical quadrature">'''Numerical quadrature'''</div>
## {{level|Cubature rules}}
## {{level|Numerical quadrature (cubature) rules on an interval (for a multidimensional cube)}}
### [[Numerical quadrature (cubature) rules on an interval (for a multidimensional cube)#Rectangle rule|Rectangle rule]]
### [[Numerical quadrature (cubature) rules on an interval (for a multidimensional cube)#Trapezoid rule|Trapezoid rule]]
### [[Numerical quadrature (cubature) rules on an interval (for a multidimensional cube)#Simpson rule|Simpson rule]]
### [[Numerical quadrature (cubature) rules on an interval (for a multidimensional cube)#Gauss rule|Gauss rule]]
# <div id="Graph algorithms">'''Graph algorithms'''</div>
## Traversing a graph
### {{level|Breadth-first search (BFS)}}
### {{level|Depth-first search (DFS)}}
## {{level|Single source shortest path (SSSP)}}
### {{level|Breadth-first search (BFS)}} (for unweighted graphs)
### {{level|Dijkstra's algorithm}}
### {{level|Bellman-Ford algorithm}}
### {{level|Δ-stepping algorithm}}
## {{level|All pairs shortest path (APSP)}}
### {{level|Johnson's algorithm}}
### {{level|Floyd-Warshall algorithm}}
## {{level|Transitive closure of a directed graph}}
### {{level|Purdom's algorithm}}
## {{level|Longest shortest path}}
## {{level|Construction of the minimum spanning tree (MST)}}
### {{level|Boruvka's akgorithm}}
### {{level|Kruskal's algorithm}}
### {{level|Prim's algorithm}}
### {{level|GHS algorithm}}
## {{level|Search for isomorphic subgraphs}}
### {{level|Ullman's algorithm}}
### {{level|VF2 algorithm}}
## {{level|Graph connectivity}}
### {{level|Shiloach-Vishkin algorithm for finding the connected components}}
### {{level|Disjoint set union}}
### {{level|Tarjan's strongly connected components algorithm}}
### {{level|DCSC algorithm for finding the strongly connected components}}
### {{level|Tarjan's biconnected components algorithm}}
### {{level|Tarjan-Vishkin biconnected components algorithm}}
### {{level|Tarjan's algorithm for finding the bridges of a graph}}
### {{level|Vertex connectivity of a graph}}
### {{level|Gabow's edge connectivity algorithm}}
## {{level|Finding maximal flow in a transportation network}}
### {{level|Ford–Fulkerson algorithm}}
### {{level|Preflow-Push algorithm}}
## {{level|Finding minimal-cost flow in a transportation network}}
## {{level|Assignment problem}}
### {{level|Hungarian algorithm}}
### {{level|Auction algorithm}}
### {{level|Hopcroft–Karp algorithm}}
## {{level|Betweenness centrality algorithm|Finding the betweenness centrality of vertices}}
# <div id="Search algorithms">'''Search algorithms'''</div>
## {{level|Binary search: Finding the position of a target value within a sorted array}}, <math>O(log(n))</math>
# <div id="Sorting algorithms">'''Sorting algorithms'''</div>
## {{level|Binary tree sort}}
## {{level|Bubble sort}}
## {{level|Merge sort (serial and parallel variants)}}
# <div id="Computational geometry">'''Computational geometry'''</div>
## {{level|Finding the diameter of a point set}}
## {{level|Finding the convex hull of a point set}}
## {{level|Delaunay triangulation}}
## {{level|Voronoi diagram}}
## {{level|Point-in-polygon problem}}
## {{level|Convex polygon intersection}} - complexity <math>O(n_1 + n_2)</math>
## {{level|Star-shaped polygon intersection}} - complexity <math>O(n_1 * n_2)</math>
# <div id="Computer graphics">'''Computer graphics'''</div>
## {{level|Line drawing algorithms: Approximating a line segment on discrete graphical media}}
## {{level|Determining visible parts of a three-dimensional scene}}
## {{level|Ray tracing: Rendering realistic images}}
## {{level|Global illumination: Regarding direct illumination and reflection from other objects}}
# <div id="Cryptographic algorithms">'''Cryptographic algorithms'''</div>
# <div id="Нейронные сети">'''Neural networks'''</div>
# <div id="Optimization algorithms">'''Optimization algorithms'''</div>
## {{level|Linear programming}}
## {{level|Simplex algorithm}}
## {{level|Branch and bound method (serial and parallel variants)}}
## {{level|Genetic algorithms}}
## {{level|Ant colony algorithms}}
## {{level|Hybrid algorithms}}
## {{level|Finding extrema of a function}}
# <div id="Game theory algorithms">'''Game theory algorithms'''</div>
# <div id="Algorithms for quantum system simulation">'''Algorithms for quantum system simulation'''</div>
## ''Algorithms for quantum computation simulation''
### {{level|Single-qubit transform of a state vector}}
### {{level|Two-qubit transform of a state vector}}
### {{level|Quantum Fourier transform simulation}}
# <div id="Algorithms for solving equations of mathematical physics">'''Algorithms for solving equations of mathematical physics'''</div>
## {{level|Poisson equation: Solving with DFT}}
# <div id="Other algorithms">'''Other algorithms'''</div>

Алговики:Правила

2016-11-01T15:18:47Z

Lineprinter:

= Роли в проекте =

== Кто может стать автором AlgoWiki? ==
Автором AlgoWiki может стать любой пользователь сети Интернет, желающий внести свой вклад в описание структуры и/или особенностей реализации алгоритмов как для традиционных, так и для перспективных вычислительных систем.

= Регистрация в проекте =

== Как зарегистрироваться на сайте? ==
Для регистрации на сайте нажмите ссылку "Войти" на главной странице и далее ссылку "запросить" (можно сразу зайти по ссылке http://algowiki-project.org/ru/Служебная:Запросить_учётную_запись.

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

== Что может быть причиной отказа в регистрации? ==
Причин для отказа в регистрации нет.

= Правка существующих страниц =

== Кто может вносить правки в существующие страницы? ==
Правки в существующие страницы может вносить любой зарегистрированный пользователь.

== Когда внесённые правки появятся на странице? ==
Внесённые правки станут видны всем пользователям после утверждения редактором сайта.

= Создание новых страниц =

== Кто может создать новую страницу? ==
Новую страницу может создать любой зарегистрированный пользователь.

== Как создать новую страницу? ==
Для создания новой страницы нужно на любой существующей странице вставить конструкцию <nowiki>[[Новая страница]]</nowiki>. Затем надо перейти по получившейся ссылке и отредактировать созданную станицу. Подробнее про способы создания новой страницы в MediaWiki можно прочитать [https://www.mediawiki.org/wiki/Help:Starting_a_new_page/ru здесь].

== Какой должна быть структура создаваемой страницы? ==
Структура описания алгоритма должна строго соответствовать структуре, описанной [[Структура_описания_свойств_алгоритмов|здесь]]. Если возникнут предложения по модификации данной структуры, соответствующие предложения присылайте [mailto:info@algowiki-project.org авторам проекта]. Если автор не обладает информацией по некоторым разделам описания, данные разделы могут быть оставлены незаполненными.

== Как вписать новую страницу в структуру проекта? ==
Все новые страницы с описаниями алгоритмов требуется вписать в [[Классификация_алгоритмов|классификацию алгоритмов]]. Для каждого алгоритма нужно найти наиболее подходящий раздел в классификации либо создать новый раздел. Возможно вхождение алгоритмов одновременно в несколько разделов.

[[Категория:Algowiki:Справка]]

Алговики:Технический форум

2016-11-01T15:18:24Z

Lineprinter:

{{project internals nav}}

== Свежие на момент 2016-11-01 изменения ==
* Починен redirect loop на страницах с символами +, ', ", =, \.
* Mediawiki обновлена до 1.26.4.
* Появился [[Ш:Doc]] для документации шаблонов.
* Заполнен [[MediaWiki:Edittools]] на основе [[ru-wikipedia:MediaWiki:Edittools]].

— [[S:Contributions/Lineprinter|lineprinter]] 11:11, 1 ноября 2016 (MSK)

== Свежие на момент 2016-10-07 изменения ==
* Введен обязательный https.
* Сертификат заменен на Let's Encrypt'овский.
* Введена капча на регистрацию и на повторные попытки входа в систему.
* Открыта регистрация.
* Введены дополнительные, короткие, редиректы на неймспейсы:
** '''Ш''' и '''T''' для '''Ш'''аблонов ('''T'''emplate)
** '''К''' и '''C''' для '''К'''атегорий ('''C'''ategory)
** '''С''' и '''S''' для '''С'''лужебных ('''S'''pecial)
** '''U''' для пользователей ('''U'''ser)
** '''Ф''' и '''F''' для '''Ф'''айлов ('''F'''ile)
** '''А''' и '''A''' для '''А'''лговики ('''A'''lgowiki)
: Таким образом, на страницу [[Алговики:Общий форум]] можно попасть по [[А:Общий форум]], например.
* Появился новый [[Ш:Плашка]], который предполагается использовать для создания производных от него шаблонов (например [[Ш:Assignment]])

— [[S:Contributions/Lineprinter|lineprinter]] 14:27, 7 октября 2016 (MSK)

Категория:Алгоритмы

2016-11-01T15:17:23Z

Lineprinter: Полностью удалено содержимое страницы

Категория:Algowiki:Справка

2016-11-01T15:17:16Z

Lineprinter: Полностью удалено содержимое страницы

Категория:Блочные алгоритмы

2016-11-01T15:15:37Z

Lineprinter:

'''Блочные алгоритмы''' - алгоритмы, имеющие какой-либо точечный аналог, но в которых основными операциями являются не операции над числами, а операции над блоками (фрагментами матриц).

[[Категория:Алгоритмы для матриц]]

Категория:Методы конструирования параллельных алгоритмов

2016-11-01T15:14:37Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Frolov

'''Методы конструирования параллельных алгоритмов''' - общие приёмы, с помощью которых на основе одних алгоритмов конструируются другие, специально для параллельных вычислительных систем.

Категория:Уровень метода

2016-11-01T15:14:12Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Nebaruzdin

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

[[en:Category:Method level]]

Категория:Уровень задачи

2016-11-01T15:14:00Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Nebaruzdin

'''Уровень задачи''' в категории означает, что в статье описана задача, которую, возможно, решают несколько методов.

[[en:Category:Problem level]]

Категория:Уровень алгоритма

2016-11-01T15:13:39Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Nebaruzdin

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

[[en:Category:Algorithm level]]

О проекте

2016-11-01T15:12:32Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии ASA

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

----

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

Увы, но нет никаких оснований надеяться, что ситуация в будущем изменится к лучшему. Уже сейчас рассматриваются перспективные варианты архитектур, где будут использованы легкие и/или тяжелые вычислительные ядра, ускорители разного типа, идеи SIMD и data-flow обработки. В такой ситуации, для полного использования потенциала будущих компьютеров нужно будет опять переписывать код. Бесконечный процесс, который оптимизма у разработчиков программного обеспечения не вызывает.

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

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

Идея глубокого априорного анализа свойств алгоритмов и их реализаций легла в основу проекта AlgoWiki, начатого в НИВЦ МГУ. Основная задача проекта – составить такое описание фундаментальных свойств алгоритмов, которое даст полное понимание как их теоретического потенциала, так и особенностей их реализации на различных классах параллельных вычислительных систем.
Описание всех алгоритмов в AlgoWiki строится из двух частей. В первой части описываются собственно алгоритмы и их свойства. Вторая часть посвящена описанию особенностей их программной реализации с учетом конкретных программно-аппаратных платформ. Такое деление на две части сделано для того, чтобы машинно-независимые свойства алгоритмов, определяющие их потенциал и качество реализации на параллельных вычислительных системах, были бы выделены и описаны отдельно от множества вопросов, связанных с последующими этапами программирования алгоритмов и исполнения результирующих программ.

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

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

Точно также важны и детали, касающиеся особенностей реализации алгоритмов на конкретных параллельных вычислительных платформах: многоядерных процессорах, SMP, кластерах, разного рода ускорителях, с использованием векторной обработки. Во многих случаях нужно спускаться еще на уровень ниже, описывая особенности реализации алгоритма не просто для ускорителя, а выделяя отдельно важные частные случаи, например, GPU и Xeon Phi. Полезными являются и данные вычислительных экспериментов на похожих платформах, различающихся, например, разными объемами кэш-памяти, деталями реализации векторной обработки или латентностью коммуникационной сети. При этом, приводя данные о времени выполнения, эффективности и масштабируемости, мы не только даем некоторые ориентиры возможного качества реализации алгоритма на конкретном компьютере, но и формируем базу для сравнительного анализа различных компьютерных платформ на алгоритмах, представленных в AlgoWiki.

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

Работа поддержана грантом [http://РНФ.рф Российского научного фонда] (проект N14-11-00190).

== Основные публикации по проекту ==

* Теплов А.М. Об одном подходе к сравнению масштабируемости параллельных программ // Вычислительные методы и программирование: Новые вычислительные технологии (Электронный научный журнал). Том 15, выпуск 4, 2014. С. 697-711. http://num-meth.srcc.msu.ru/zhurnal/tom_2014/pdf/v15r161.pdf
* Вл.В.Воеводин "Открытая энциклопедия свойств алгоритмов AlgoWiki: от мобильных платформ до экзафлопсных суперкомпьютерных систем" // Вычислительные методы и программирование: Новые вычислительные технологии (Электронный научный журнал). Том 16, раздел 1, 2015. С. 99-111. http://num-meth.srcc.msu.ru/zhurnal/tom_2015/pdf/v16r111.pdf
* А.С.Антонов, Вад.В.Воеводин, Вл.В.Воеводин, А.М.Теплов, А.В.Фролов. Первая версия Открытой энциклопедии свойств алгоритмов // Вестник УГАТУ. Серия управление, вычислительная техника и информатика. Том 19, N 2(68), 2015. С. 150-159. http://journal.ugatu.ac.ru/index.php/vestnik/article/view/1460
* А.В.Фролов, Вад.В.Воеводин, И.Н.Коньшин, А.М.Теплов. Исследование структурных свойств алгоритма разложения Холецкого: от давно известных фактов до новых выводов // Параллельные вычислительные технологии (ПаВТ'2015): труды международной научной конференции (31 марта - 2 апреля 2015 г., г. Екатеринбург). Челябинск: Издательский центр ЮУрГУ, 2015. С. 320-331. http://omega.sp.susu.ac.ru/books/conference/PaVT2015/full/058.pdf
* V.Voevodin, A.Antonov, J.Dongarra. AlgoWiki: an Open Encyclopedia of Parallel Algorithmic Features // Supercomputing Frontiers and Innovations, Vol.2, No.1 (2015). Pp.4-18. http://superfri.org/superfri/article/view/69

[[En: About Project]]

Классификация алгоритмов

2016-11-01T15:12:18Z

Lineprinter:

# <div id="Векторные операции">'''Векторные операции'''</div>
## ''Суммирование сдваиванием''
### {{level|Нахождение суммы элементов массива сдваиванием}}
### {{level|Нахождение частных сумм элементов массива сдваиванием}}
## {{level|Равномерная норма вектора, вещественная версия, последовательно-параллельный вариант}}
## {{level|Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант}}
## {{level|Последовательно-параллельный метод суммирования}}
# <div id="Матрично-векторные операции">'''Матрично-векторные операции'''</div>
## {{level|Умножение плотной матрицы на вектор}}
# <div id="Матричные операции">'''Матричные операции'''</div>
## {{level|Умножение плотных матриц}}
# <div id="Разложения матриц">'''Разложения матриц'''</div>
## ''Треугольные разложения''
### Метод Гаусса (нахождение LU-разложения)
#### {{level|Метод Гаусса без перестановок}}
##### LU-разложение методом Гаусса
##### Компактная схема метода Гаусса и её модификации
###### Компактная схема метода Гаусса для плотной матрицы
###### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы и её модификации}}
####### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы, последовательный вариант}}
####### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}
####### {{level|Последовательно-параллельный алгоритм для LU-разложения трёхдиагональной матрицы}}
#### Метод Гаусса с перестановками
##### Метод Гаусса с выбором ведущего элемента по столбцу
##### Метод Гаусса с выбором ведущего элемента по строке
##### Метод Гаусса с выбором ведущего элемента по главной диагонали
##### Метод Гаусса с выбором ведущего элемента по всей матрице
### {{level|Метод Холецкого (нахождение симметричного треугольного разложения)}}
#### {{level|Разложение Холецкого (метод квадратного корня)}} базовый точечный вещественный вариант для плотной симметричной положительно-определённой матрицы
### {{level|Известные треугольные разложения для матриц специального вида}}
## ''Унитарно-треугольные разложения''
### {{level|Метод Гивенса (вращений) QR-разложения матрицы}}
### {{level|Метод Хаусхолдера (отражений) QR-разложения матрицы}}
## ''Разложения на унитарные и хессенберговы матрицы''
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (двухдиагональной) форме}}
### {{level|Метод Гивенса (вращений) приведения матрицы к хессенберговой (двухдиагональной) форме}}
## ''Разложения на унитарные и диагональные матрицы''
### {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
### {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
# <div id="Решение систем линейных уравнений">'''Решение систем линейных уравнений'''</div>
## Прямые методы решения СЛАУ
### {{level|Linpack benchmark}}
### Методы решения СЛАУ с матрицами специального вида
#### Методы решения СЛАУ с треугольными матрицами
##### {{level|Прямая подстановка (вещественный вариант)|Прямая подстановка}}
##### {{level|Обратная подстановка (вещественный вариант)|Обратная подстановка}}
##### Методы решения СЛАУ с двухдиагональными матрицами
###### {{level|Прямая и обратная подстановка в СЛАУ с двухдиагональной матрицей}}
###### {{level|Метод сдваивания Стоуна для решения двухдиагональных СЛАУ}}
###### {{level|Последовательно-параллельный вариант обратной подстановки}}
#### {{level|Методы решения СЛАУ с трёхдиагональными матрицами}}
##### Методы, основанные на стандартном LU-разложении матрицы
###### {{level|Прогонка}}
####### {{level|Прогонка, точечный вариант|Классическая монотонная прогонка}}
####### {{level|Повторная прогонка, точечный вариант|Повторная прогонка для новой правой части, классическая схема}}
###### {{level|Метод сдваивания Стоуна}}
###### {{level|Последовательно-параллельный вариант решения трёхдиагональной СЛАУ с LU-разложением и обратными подстановками}}
##### Другие методы
###### {{level|Метод редукции}}
####### {{level|Полный метод редукции}}
####### {{level|Повторный метод редукции для новой правой части}}
###### Встречная прогонка
####### {{level|Встречная прогонка, точечный вариант|Классическая встречная прогонка}}
####### {{level|Повторная встречная прогонка, точечный вариант|Повторная прогонка для новой правой части, встречная схема}}
###### {{level|Метод циклической редукции}}
####### {{level|Полный метод циклической редукции}}
####### {{level|Повторный метод циклической редукции для новой правой части}}
###### {{level|Метод окаймления}}
#### Методы решения СЛАУ с блочно-треугольными матрицами
##### {{level|Блочная прямая подстановка (вещественный вариант)|Блочная прямая подстановка}}
##### {{level|Блочная обратная подстановка (вещественный вариант)|Блочная обратная подстановка}}
##### Методы решения СЛАУ с блочно-двухдиагональными матрицами
###### {{level|Прямая и обратная подстановка в СЛАУ с блочно-двухдиагональной матрицей}}
###### {{level|Метод сдваивания Стоуна для решения блочно-двухдиагональных СЛАУ}}
###### {{level|Блочный последовательно-параллельный вариант обратной подстановки для решения блочно-двухдиагональных СЛАУ}}
#### {{level|Методы решения СЛАУ с блочно-трёхдиагональными матрицами}}
##### Методы, основанные на стандартном LU-разложении матрицы
###### {{level|Блочная прогонка}}
###### {{level|Блочный последовательно-параллельный вариант решения с LU-разложением и обратными подстановками}}
##### Другие методы
###### {{level|Встречная прогонка, блочный вариант}}
###### {{level|Блочный метод циклической редукции}}
###### {{level|Блочный метод окаймления}}
### {{level|Решения СЛАУ с матрицами специального вида, имеющими известные обратные матрицы}}
## Итерационные методы решения СЛАУ
### {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
# <div id="Решения спектральных задач">'''Решения спектральных задач'''</div>
## {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
### {{level|QR-алгоритм}}
### {{level|Метод Гивенса (вращений) для решения спектральной задачи у симметричных матриц}}
## {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
# <div id="Тесты производительности компьютеров">'''Тесты производительности компьютеров'''</div>
## {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
## {{level|Linpack benchmark}}
# <div id="Преобразование Фурье">'''Преобразование Фурье'''</div>
## {{level|Быстрое преобразование Фурье для степеней двойки}}
# <div id="Алгебра многочленов">'''Алгебра многочленов'''</div>
## {{level|Схема Горнера, вещественная версия, последовательный вариант|Схема Горнера}}
# <div id="Численные методы интегрирования">'''Численные методы интегрирования'''</div>
## {{level|Квадратурные формулы}}
## {{level|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)}}
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод прямоугольников|Метод прямоугольников]]
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод трапеций|Метод трапеций]]
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод парабол (метод Симпсона)|Метод парабол (метод Симпсона)]]
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод Гаусса|Метод Гаусса]]
# <div id="Алгоритмы на графах">'''Алгоритмы на графах'''</div>
## Обход графа
### {{level|Поиск в ширину (BFS)}}
### {{level|Поиск в глубину (DFS)}}
## {{level|Поиск кратчайшего пути от одной вершины (SSSP)}}
### {{level|Поиск в ширину (BFS)}} (для невзвешенных графов)
### {{level|Алгоритм Дейкстры}}
### {{level|Алгоритм Беллмана-Форда}}
### {{level|Алгоритм Δ-шагания}}
## {{level|Поиск кратчайшего пути для всех пар вершин (APSP)}}
### {{level|Алгоритм Джонсона}}
### {{level|Алгоритм Флойда-Уоршелла}}
## {{level|Поиск транзитивного замыкания орграфа}}
### {{level|Алгоритм Пурдома}}
## {{level|Определение диаметра графа}}
## {{level|Построение минимального остовного дерева (MST)}}
### {{level|Алгоритм Борувки}}
### {{level|Алгоритм Крускала}}
### {{level|Алгоритм Прима}}
### {{level|Алгоритм GHS}}
## {{level|Поиск изоморфных подграфов}}
### {{level|Алгоритм Ульмана}}
### {{level|Алгоритм VF2}}
## {{level|Связность в графах}}
### {{level|Алгоритм Шилоаха-Вишкина поиска компонент связности}}
### {{level|Система непересекающихся множеств}}
### {{level|Алгоритм Тарьяна поиска компонент сильной связности}}
### {{level|Алгоритм DCSC поиска компонент сильной связности}}
### {{level|Алгоритм Тарьяна поиска компонент двусвязности}}
### {{level|Алгоритм Тарьяна-Вишкина поиска компонент двусвязности}}
### {{level|Алгоритм Тарьяна поиска «мостов» в графе}}
### {{level|Определение вершинной связности графа}}
### {{level|Алгоритм Габова определения рёберной связности графа}}
## {{level|Поиск максимального потока в транспортной сети}}
### {{level|Алгоритм Форда-Фалкерсона}}
### {{level|Алгоритм проталкивания предпотока}}
## {{level|Поиск потока минимальной стоимости в транспортной сети}}
## {{level|Задача о назначениях}}
### {{level|Венгерский алгоритм}}
### {{level|Алгоритм аукциона}}
### {{level|Алгоритм Гопкрофта-Карпа}}
## {{level|Вычисление betweenness centrality|Вычисление центральности вершин}}
# <div id="Алгоритмы поиска">'''Алгоритмы поиска'''</div>
## {{level|Линейный поиск - находит элемент в любом списке|Линейный поиск}}, <math>O(n)</math>
## {{level|Двоичный поиск - находит элемент в отсортированном списке|Двоичный поиск}}, <math>O(log(n))</math>
# <div id="Алгоритмы сортировки">'''Алгоритмы сортировки'''</div>
## {{level|Сортировка с помощью двоичного дерева}}
## {{level|Сортировка пузырьком}}
## {{level|Сортировка слиянием (последовательный и параллельный варианты)}}
# <div id="Вычислительная геометрия">'''Вычислительная геометрия'''</div>
## {{level|Поиск диаметра множества точек}}
## {{level|Построение выпуклой оболочки набора точек}}
## {{level|Триангуляция Делоне}}
## {{level|Диаграмма Вороного}}
## {{level|Принадлежность точки многоугольнику}}
## {{level|Пересечения выпуклых многоугольников}} - трудоёмкость <math>O(n_1 + n_2)</math>
## {{level|Пересечение звёздных многоугольников}} - трудоёмкость <math>O(n_1 * n_2)</math>
# <div id="Компьютерная графика">'''Компьютерная графика'''</div>
## {{level|Алгоритмы построения отрезка - алгоритмы для аппроксимации отрезка на дискретной графической поверхности}}
## {{level|Алгоритм определения видимых частей трёхмерной сцены}}
## {{level|Трассировка лучей - рендеринг реалистичных изображений}}
## {{level|Глобальное освещение - рассматривает прямое освещение и отражение от других объектов}}
# <div id="Криптографические алгоритмы">'''Криптографические алгоритмы'''</div>
# <div id="Нейронные сети">'''Нейронные сети'''</div>
# <div id="Алгоритмы оптимизации">'''Алгоритмы оптимизации'''</div>
## {{level|Линейное программирование}}
## {{level|Симплекс-метод}}
## {{level|Метод ветвей и границ (последовательный и параллельный варианты)}}
## {{level|Генетические алгоритмы}}
## {{level|Муравьиные алгоритмы}}
## {{level|Комбинированные алгоритмы}}
## {{level|Нахождение экстремума функции}}
# <div id="Алгоритмы теории игр">'''Алгоритмы теории игр'''</div>
# <div id="Алгоритмы моделирования квантовых систем">'''Алгоритмы моделирования квантовых систем'''</div>
## ''Алгоритмы моделирования квантовых вычислений''
### {{level|Однокубитное преобразование вектора-состояния}}
### {{level|Двухкубитное преобразование вектора-состояния}}
### {{level|Моделирование квантового преобразования Фурье}}
# <div id="Алгоритмы решения уравнений математической физики">'''Алгоритмы решения уравнений математической физики'''</div>
## {{level|Уравнение Пуассона, решение дискретным преобразованием Фурье}}
# <div id="Другие алгоритмы">'''Другие алгоритмы'''</div>

[[en:Algorithm classification]]

[[Категория:Алгоритмы|*]]

Готовность статей

2016-11-01T15:11:36Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Nebaruzdin

{| width="100%"
|- valign="top"
| '''Начатые статьи''':
<DynamicPageList>
category = Начатые статьи
</DynamicPageList>
| '''Статьи в работе''':
<DynamicPageList>
category = Статьи в работе
</DynamicPageList>
| '''Законченные статьи''':
<DynamicPageList>
category = Законченные статьи
</DynamicPageList>
|}

Категория:Статьи по готовности

2016-11-01T15:11:32Z

Lineprinter: Откат правок AntonChupin (обсуждение) к версии Nebaruzdin

Подкатегории данной категории используются в шаблоне [[Шаблон:Main page/Readiness|Main page/Readiness]].

[[en:Category:Articles by readiness]]

Шаблон:Lang

2016-11-01T15:10:25Z

Lineprinter:

Шаблон:Lang-en

2016-11-01T15:10:17Z

Lineprinter:

[https://ru.wikipedia.org/wiki/английский_язык англ.] ''{{lang|en|{{{1}}}}}''

Шаблон:Lang

2016-11-01T15:10:02Z

Lineprinter: