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

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

2016-12-16T13:14:41Z

Davletshuna Alexandra: /* По существу */

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

=== По существу ===

* Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK, LINPACK/EISPACK, Intel MKL - и где ссылки? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 14:09, 10 ноября 2016 (MSK)
* Односторонние вращения могут быть перестановочными, учтите это при вычислении параллельной сложности. --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 14:09, 10 ноября 2016 (MSK)
* Проверьте формулы - в части из них ошибки, исправьте их. --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 14:09, 10 ноября 2016 (MSK)
** При тау=0 случай не разобран. --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 16:05, 5 декабря 2016 (MSK)
*** Всё исправили

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:16, 25 октября 2016 (MSK)
** Вклад авторов статьи так и не указан. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:53, 2 ноября 2016 (MSK)

=== Замечания по тексту ===
* На рис.1 представлена трёхмерная структура а в комментарии к ней написано "Первая группа вершин расположена в двумерной области..." - непонятно, как это сочетается. Подпись к Рис.1 совершенно непонятна, чему соответствуют вершины, дуги и оси - не сказано. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:16, 25 октября 2016 (MSK)
* Вторая и третья группа вершин никак не иллюстрируются? [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:16, 25 октября 2016 (MSK)
* Рис.2 совершенно непонятен и никак не пояснён. Чему соответствуют разные вершины? Чему соответствуют дуги? Непонятно даже количество вершин в графе. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:16, 25 октября 2016 (MSK)
** Графы стали намного понятнее, но уж очень некрасиво выглядят... [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:53, 2 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:59, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 13:56, 18 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 13:56, 18 ноября 2016 (MSK)

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

2016-12-09T11:07:45Z

Davletshuna Alexandra:

{{Assignment|ASA}}
{{Assignment}}

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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> a_{jj} = a_{kk} </math> считаем <math> sign(\tau) = 1 </math>, т. е. <math> \theta =
\pi/4 </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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой средe суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-12-09T11:06:50Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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> a_{jj} = a_{kk} </math> считаем <math> sign(\tau) = 1 </math>, т. е. <math> \theta =
\pi/4 </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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой средe суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-12-09T11:05:31Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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> a_{jj} = a_{kk} </math> считаем <math> sign(\tau) = 1 </math>, т. е. <math> \theta = pi/4 </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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой средe суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-20T08:48:52Z

Davletshuna Alexandra:

{{Assignment}}

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой средe суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-20T08:47:35Z

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

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой средe суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-20T08:47:13Z

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

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на тестовой среду суперкомпьютера "Ломоносов", с использованием компилятора ICC и библиотеки impi/4.0.3. Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

[https://www.dropbox.com/home?preview=mainmpi.c Исследованная параллельная реализация метода Якоби]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T16:15:10Z

Davletshuna Alexandra:

{{Assignment}}

{{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); [[Участница:Alek sandra|Зайцева Александра]]. Вклад каждого участника считать равноценным.

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T16:14:13Z

Davletshuna Alexandra:

{{Assignment}}

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T16:13:09Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

*По размеру задачи: при увеличении размера задачи эффективность возрастает. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается.

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

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T15:56:33Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:Эффективность.png|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:44:45Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1] </math>, <math> k \in [j+1,n] </math>
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:43:24Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Для всех <math> j </math> и <math> k </math> таких, что <math> j \in [1,n-1 </math>.
##Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
##Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:40:38Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
##Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
#Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:33:27Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
#Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы: Вычисление элементов <math> \tau, t, c, s </math>.
#Затем, выполняется операция поворота, путем перемножения матриц <math> G </math> и <math> R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^TG </math> не станет достаточно близкой к диагональной.

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

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:32:13Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
#Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы:Вычисление элементов <math> \tau, t, c, s </math>.
#Затем, выполняется операция поворота, путем перемножения матриц <math> G*R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^T*G </math> не станет достаточно близкой к диагональной.

Для проверки этого факта, в конце каждой итерации цикла вычисляется матрица <math> A = G^T*G </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы, после чего результат пересылается всем процессорам.

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:31:40Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
#Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы:Вычисление элементов <math> tau, t, c, s </math>.
#Затем, выполняется операция поворота, путем перемножения матриц <math> G*R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^T*G </math> не станет достаточно близкой к диагональной.

Для проверки этого факта, в конце каждой итерации цикла вычисляется матрица <math> A = G^T*G </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы, после чего результат пересылается всем процессорам.

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:30:37Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

Алгоритм работает по следующей схеме:
#На вход всем процессорам подается матрица <math> G </math>.
#Вычисляется элемент <math> a_{jk} </math> путем перемножения матриц <math> G^TG </math>, где на каждом процессоре вычисляется своя часть матрицы. После чего результат отправляется на все процессоры.
#Если полученный элемент оказывается больше некоторого значения, то начинается последовательная часть программы:
#Вычисление элементов <math> tau, t, c, s </math>.
#Затем, выполняется операция поворота, путем перемножения матриц <math> G*R </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы. После чего результат пересылается всем процессорам.

Данная схема повторяется до тех пор, пока матрица <math> A = G^T*G </math> не станет достаточно близкой к диагональной.

Для проверки этого факта, в конце каждой итерации цикла вычисляется матрица <math> A = G^T*G </math>. Данная операция выполняется параллельно на нескольких процессорах, где каждый процессор вычисляет свою часть матрицы, после чего результат пересылается всем процессорам.

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:06:15Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T12:03:22Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов". Алгоритм реализован на языке программирования C с использованием механизмов MPI.

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T06:30:42Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов".

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:EfficiencyJackobi.jpg|none|thumb|1000px|Рисунок 2. Параллельная реализация метода Якоби. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-17T06:30:09Z

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

{{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>s</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>.

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости параллельной реализации метода Якоби вычисления сингулярных чисел и векторов проводилось на суперкомпьютере "Ломоносов".

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

* число процессоров [1 : 128] с шагом равным степени двойки;
* размер матрицы [256 : 1792] с шагом 256.

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

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

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

[[File:Performance.jpg|none|thumb|1000px|Рисунок 1. Параллельная реализация метода Якоби. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[[File:EfficiencyJackobi.jpg|none|thumb|1000px|Рисунок 2. Параллельная реализация метода Холецкого. Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

=== Существующие реализации алгоритма ===
Метод Якоби нахождения сингулярных значений и векторов реализован в таких пакетах, как LAPACK <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-16T12:56:17Z

Davletshuna Alexandra: /* Существующие реализации алгоритма */

{{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>s</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 <ref>http://www.netlib.org/scalapack/slug/</ref>, LINPACK/EISPACK <ref> http://www.netlib.org/linpack/ </ref>, Intel MKL <ref>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-15T19:07:44Z

Davletshuna Alexandra: /* Ресурс параллелизма алгоритма */

{{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>s</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>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-15T19:05:02Z

Davletshuna Alexandra: /* Схема реализации последовательного алгоритма */

{{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>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-15T19:04:24Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

{{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>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-15T19:03:56Z

Davletshuna Alexandra: /* Существующие реализации алгоритма */

{{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>https://software.intel.com/ru-ru/node/521153#CAF8CA08-1C69-48F8-B0C3-B2B27AFA92FA</ref>.

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

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

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

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

2016-11-03T13:31:04Z

Davletshuna Alexandra:

{{Assignment}}

{{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.

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

2016-11-03T13:30:29Z

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

{{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.

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

2016-11-03T10:13:39Z

Davletshuna Alexandra:

{{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:Graf2.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.

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

2016-11-01T20:43:31Z

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

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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:Graf2.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.

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

2016-11-01T20:31:27Z

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

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>a_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>r_{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:Graf2.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.

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

2016-11-01T20:26:44Z

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

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

Граф вычисления каждого из элементов приведен на рисунке 1, где значениям <math>a_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>r_{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:Graf2.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.

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

2016-11-01T20:25:05Z

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

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

Граф вычисления каждого из элементов приведен на рисунке 1, где значениям <math>a_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>r_{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. ]]

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

[[File:Graf2.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.

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

2016-11-01T20:22:41Z

Davletshuna Alexandra:

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

Граф вычисления каждого из элементов приведен на рисунке 1, где значениям <math>a_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>r_{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. ]]

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

[[File:Graf2.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.

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

2016-11-01T20:21:22Z

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

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

Граф вычисления каждого из элементов приведен на рисунке 1, где значениям <math>a_{ij}</math> соответствуют обозначения <math>x_{ij}</math>, а элементам <math>r_{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. ]]

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

[[File:Graf2.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.

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

2016-11-01T19:50:35Z

Davletshuna Alexandra: /* Вычислительное ядро алгоритма */

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

[[File:Graf1.png|none|thumb|2000px|Рисунок 1. Информационная структура вычисления данных параметром.]]

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

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

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации метода Якоби требуется последовательно выполнить несколько ярусов:
# вычислить <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.

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

2016-10-15T20:04:31Z

Davletshuna Alexandra:

{{Assignment}}

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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\, a_{jj}^{(i)} - 2\, s c \,g_{jk}^{(i)} + s^2\, g_{kk}^{(i)} \\
g_{kk}^{(i+1)} &= s^2 \,a_{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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

[[File:Graf1.png|none|thumb|2000px|Рисунок 1. Информационная структура вычисления данных параметром.]]

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

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

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации метода Якоби требуется последовательно выполнить несколько ярусов:
# вычислить <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.

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

2016-10-15T20:02:33Z

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

{{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), [[Участница:Alek sandra|Зайцева Александра]] (группа 601)

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

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

• левые сингулярные векторы матрицы А — это собственные векторы матрицы <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\, a_{jj}^{(i)} - 2\, s c \,g_{jk}^{(i)} + s^2\, g_{kk}^{(i)} \\
g_{kk}^{(i+1)} &= s^2 \,a_{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>j</math> изменяется от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения, <math>k</math> изменяется от <math>j+1</math> до <math>n</math>, принимая все целочисленные значения.

[[File:Graf1.png|none|thumb|2000px|Рисунок 1. Информационная структура вычисления данных параметром.]]

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

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

=== Ресурс параллелизма алгоритма ===
Для выполнения одной итерации метода Якоби требуется последовательно выполнить несколько ярусов:
# вычислить <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.

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

2016-10-15T14:33:27Z

Davletshuna Alexandra: /* Последовательная сложность алгоритма */

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

2016-10-15T14:28:51Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

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

2016-10-15T14:27:55Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

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

2016-10-15T14:27:35Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

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

2016-10-15T14:25:15Z

Davletshuna Alexandra: /* Вычислительное ядро алгоритма */

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

2016-10-15T14:23:31Z

Davletshuna Alexandra: /* Ресурс параллелизма алгоритма */

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

2016-10-15T14:22:06Z

Davletshuna Alexandra: /* Вычислительное ядро алгоритма */

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

2016-10-15T13:43:43Z

Davletshuna Alexandra: /* Математическое описание алгоритма */

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

2016-10-15T13:34:16Z

Davletshuna Alexandra: /* Существующие реализации алгоритма */

Участник:Alek sandra

2016-10-15T12:51:22Z

Davletshuna Alexandra:

Студентка 601 группы ВМК МГУ Зайцева Александра

Участник:Alek sandra

2016-10-15T12:50:38Z

Davletshuna Alexandra: Новая страница: «Студентка 601 группы ВМК МГУ»

Студентка 601 группы ВМК МГУ