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

Метод Якоби вычисления сингулярных чисел и векторов
Последовательный алгоритм
Последовательная сложность	$O(n^3)$
Объём входных данных
Объём выходных данных
Параллельный алгоритм
Высота ярусно-параллельной формы
Ширина ярусно-параллельной формы

Авторы статьи: Почернина Елена (группа 601), Костюкова Светлана (группа 601)

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

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

Метод Якоби для вычисления сингулярных чисел и векторов является самым медленным из имеющихся алгоритмов поиска сингулярных чисел и векторов, но тем не менее, интерес к нему сохраняется. Для некоторых некоторых типов матриц $G$ он способен вычислять сингулярные числа и векторы намного точнее, чем другие методы. В частности, метод Якоби вычисляет сингулярные числа матрицы $G$ с высокой точностью, если G может быть представлена в виде $G = DX$, где $D$ – диагональная матрица, а $X$ – хорошо обусловлена. В этом случае заданная матрица обрабатывается без предварительного приведения к двухдиагональному виду, в то время как другие алгоритмы включают в себя приведение матрицы к двухдиагональной форме, из-за чего и теряют все верные разряды во всех сингулярных числах, кроме старшего.

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

Исходные данные: матрица $G$ (элементы $g_{ij}, i, j = 1, \ldots, n$).

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

Матрица $A = G^TG$.

Основной алгоритм заключается в следующем:

Для всех элементов матрицы $A^{(i)}$, находящихся вне главной диагонали $(a_{12}, a_{13},\dots, a_{1n}, a_{23}, a_{24},\dots, a_{2n},\dots, a_{n-1n})$ проверяем условие $|A_{jk}|\lt \epsilon$: Если $|A_{jk}^{(i)}| \le \epsilon$, то переходим к следующему элементу, Если $|A_{jk}^{(i)}| \gt \epsilon$, то нужно выполнить вращение в плоскости $(jk)$, после чего перейти к следующей итерации алгоритма. Если на очередной итерации не было совершено ни одного вращения, значит матрица $A$ стала достаточна близка к диагональной, и можно перейти к вычислению искомых значений:

$\sigma_i = ||G(:,i)||_2$;

$U = [u_1,\dots,u_n]$, где $u_i = G(:,i)/\sigma_i$;

$V = J$, где $J$ - накопленное произведение вращений Якоби.

Одностороннее вращение в плоскости $(jk)$ осуществляет процедура One-Sided-Jacobi-Rotation$(G,j,k)$:

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

Здесь $R(j,k,\theta)$ - матрица вращений Якоби. Матрица вращений выбирается так, чтобы обнулить пару внедиагональных элементов.

                                                                                 $\begin{matrix} & & & & j & & k & & & \\ \end{matrix}$

$J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix}$ $\begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}$

Для завершения описания алгоритма, нужно указать критерий останова, то есть объяснить смысл условия "если $a_{jk}$ не слишком мал". Подходящим критерием останова является условие $\begin{align} |a_{jk}| \ge \epsilon\sqrt{a_{jj}a_{kk}} \end{align}$.

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

Вычислительное ядро составляют множественные вычисления элементов матрицы $a_{jj} = (G^TG)_{jj}, a_{jk} = (G^TG)_{jk}$ и $a_{kk} = (G^TG)_{kk}$, а также вычисление промежуточной матрицы $GJ$.

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

Основную часть метода составляет процедура односторонних вращений матрицы (процедура One-Sided-Jacobi-Rotation$(G,j,k)$). Рассмотрим подробнее структуру этой процедуры.

- Вычисление $a_{jk}, a_{jj}, a_{kk} (a_{ij} = (G^TG)_{ij})$. В связи с тем, что нет необходимости каждый раз вычислять произведение $G^TG$, для вычисления каждого элемента требуется $n$ операций умножения и $(n-1)$ операций сложения. Итого, на первом шаге в сумме получаем $3n$ операций умножения и $(3n-3)$ операций сложения.

- Вычисление $\tau, c, s, t$ не представляют значительной вычислительной сложности.

- Одностороннее вращение матрицы (умножение входной матрицы на матрицу вращения).

В итоге, процедура One-Sided-Jacobi-Rotation требует $O(n)$ операций.

После выполнения алгоритма односторонних вращений необходимо вычислить искомые матрицы $S, U, V$ (матрица сингулярных чисел и матрицы левых и правых векторов).

- Вычисление сингулярных чисел $\sigma_i$ требует $n$ операций умножения.

- Вычисление $U$ требует $O(n^2)$ операций. Аналогично для матрицы $V$.

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

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

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] - накопленное произведение вращений Якоби.

Метод Якоби для нахождения сингулярных чисел и векторов матрицы $G$ также использует метод односторонних вращений (процедура 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

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

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

• делений,
• сложений (вычитаний),
• умножений.

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

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Первая группа вершин расположена в двумерной области, соответствующая ей операция - вычисление $a_{jj}, a_{jk}, a_{kk}$. Естественно введённые координаты области таковы:

• $j$ — меняется в диапазоне от $1$ до $n-1$, принимая все целочисленные значения;
• $k$ — меняется в диапазоне от $j+1$ до $n$, принимая все целочисленные значения.

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

Входные данные: плотная матрица $G$ (элементы $g_{ij}$). Дополнительные ограничения:

• $A= G^TG$ – симметрическая матрица, т. е. $a_{ij}= a_{ji}, i, j = 1, \ldots, n$.

Объём входных данных: $n^2$

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

Объём выходных данных: $2n^2 + n$

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

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

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