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

Быстрое дискретное преобразование Фурье (БПФ)

2016-12-12T07:52:50Z

Kronberg:

{{Assignment|IgorS|Kronberg}}
Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье, или спектром исходной функции, по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала, содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы «разделяй и властвуй». Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math> — число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> — простое число), то данный алгоритм напрямую не применим. На замену ему приходит алгоритм Радера, который в некотором смысле сводит задачу размерности <math>N</math> к подзадаче задаче размерности <math>N\pm 1</math> вычисления свертки, в которой допустимо и увеличение размерности до составных в том числе.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

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

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

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

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Все запуски программы[http://pastebin.com/raw/xajKb9JN] проводились на с/к Blue Gene/P с использованием библиотеки Intel MKL.

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

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

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

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

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Участник:ЕкатеринаКозырева/Алгоритм динамической иерархической кластеризации CHAMELEON

2016-11-29T14:32:38Z

Kronberg:

{{Assignment|Kronberg}}
{{algorithm
| name = Алгоритм динамической иерархической кластеризации CHAMELEON
| serial_complexity = <math>O(nm + n log n + m^2 log m)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
| pf_height = <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>
| pf_width = <math>O(n)</math>
}}

Автор описания [[Участник:ЕкатеринаКозырева|Е.А.Козырева]]
= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Алгоритм CHAMELEON был предложен в 1999 году тремя учеными из университета Миннесоты – George Karypis, Eui-Hong (Sam) Han и Vipin Kumar<ref>George Karypis, Eui-Hong (Sam) Han и Vipin Kumar, «Chameleon: Hierarchical Clustering Using Dynamic Modeling», 1999.</ref>.

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

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

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

[[File:Chameleon.png|1000px|thumb|center|Рисунок 1. Общая структура алгоритма CHAMELEON]]

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

''Исходные данные'':

* Множество из n точек <math>V= {v_{ij}}</math> в метрическом пространстве, которое задано симметрической матрицей расстояний <math>A</math> размера <math>n\times n</math>.
* <math>k</math> - количество ближайших соседей для вершин, <math>k \in N, k \leq n</math>.
* <math>l</math> - наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе, <math>l \in N, l \leq n</math>.

''Обозначения'':

* <math>G = (V, E)</math> - граф, полученный путём соединения каждой точки с её <math>k</math> ближайшими соседями.

* <math>K= \{K_{i}\}</math> - разбиение множества <math>V</math> на набор попарно непересекающихся связных подмножеств, полученное в результате выполнения второй фазы алгоритма.

* <math>G_{2} = (K, E_{2})</math> - взвешенный граф, вершинами которого являются получившиеся подграфы, а ребрами - количество ребер исходного графа, соединяющих соответствующие подграфы.

* <math>C = \{C_{i}\}</math> - итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров.

''Вспомогательные понятия''

*<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. Внутренняя связность <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа.

*<math>RI_{(C_{i},C_{j})} = \frac{|EC_{(C_{i},C_{j})}|}{(|EC_{C_{i}}|+|EC_{C_{j}}|)/2}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math>

*<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма.

*<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства<ref>http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

'''Первый этап'''

На первом этапе, согласно графо-ориентированному подходу, происходит построение графа <math>G = (V, E)</math> на матрице сходства объектов по принципу k ближайших соседей. Две вершины такого графа соединяет ребро, если объект, соответствующий любой из этих вершин попадает в число k наиболее близких объектов для объекта, соответствующего другой вершине из данной пары.
[[Файл:Снимок chameleon 2.png|2000px|thumb|Рисунок 2. Объекты в пространстве - слева, граф по принципу 1-го ближайшего соседа - по центру, граф по принципу 3-х ближайших соседей - справа ]]

'''Второй этап'''

Алгоритм разделяет полученный граф на множество сравнительно малых подграфов <math>K= \{K_{i}\}</math>. Разделение происходит последовательно. На каждом шаге выбирается подграф, содержащий наибольшее число вершин. Этот граф разделяется на два подграфа так, что разделитель ребер графа минимален и каждый из получаемых подграфов содержит не менее 25 % вершин исходного графа. Процесс разделения останавливается, когда наибольший подграф содержит меньше некоторого заданного числа вершин. Обычно величина этого параметра задается равной значению от 1 до 5 % от числа объектов. Полученное множество связных графов считается множеством начальных кластеров, на котором требуется провести последовательное иерархическое объединение.

'''Третий этап'''

Третий этап заключается в итеративном преобразовании множества подграфов <math>K= \{K_{i}\}</math> в множество кластеров <math>C = \{C_{i}\}</math>. Алгоритм осуществляет агломеративную иерархическую кластеризацию на основании показателей <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math>. Существует две стратегии анализа показателей сходства. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность.

''Вычисляемые данные'':

<math>U = (u_1, u_2, ..., u_n)</math> - n-мерный вектор, где <math>u_i \in N_{[C]}</math> - порядковый номер кластера, к которому принадлежит вершина i исходного множества V.

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

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

На первом этапе вычислительным ядром является процесс нахождения <math>k</math> ближайших соседей для каждой вершины, который заключается в анализе матрицы расстояний.

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

На третьем этапе вычислительным ядром является расчет величин <math>EC_{(C_{i},C_{j})}</math>, <math>S_{EC_{(C_{i},C_{j})}}</math>, <math>RI_{(C_{i},C_{j})} </math>, <math> RC_{(C_{i},C_{j})}</math> для каждой пары смежных кластеров.

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

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

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

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

'''Первый этап'''
<source lang="cpp">
int n; //количество вершин
int k; //количество соседей
int A[n][n] //матрица расстояний
int D[k] //массив вершин-соседей
int E[n][n] //матрица ребер графа <math>G_{2} = (K, E_{2})</math>
for i=1 to n-1 do
{
for j=i+1 to n do
{
//заполняем массив вершин-соседей вставляя новые вершины, если они ближе, чем самая далекая из массива.
}
for j=0 to k do
{
//для каждой вершины соседа заполняем соответствующую ячейку из матрицы E[n][n] единицей
}

}
</source>

'''Второй этап'''

1. Все связные подграфы в отсортированном порядке помещаются в список;
2. Берем наибольший элемент списка, вычисляем количество его вершин. Если число вершин > l, то идем в пункт 3. Иначе в пункт 5;
3. Разбиваем подграф на два подграфа таким образом, чтобы разделитель ребер графа был минимален и каждый из получаемых подграфов содержал не менее 25 % вершин исходного графа;
4. Добавляем полученные элементы в список подграфов таким образом, чтобы список оставался отсортированным. Идем в пункт 2;
5. Нашли искомое множество подграфов math>K = \{K_{i}\}</math>;
6. Создаем и заполняем матрицу матрицу расстояний для графа <math>G_{2} = (K, E_{2})</math>. Получаем искомый набор рёбер <math>E_{2}</math>.

'''Третий этап'''

1. Заводим два массива: а) массив кластеров C, полученных на предыдущем этапе, б) массив объединений кластеров F, которые мы будем получать на этом этапе;
2. Берем следующий кластер <math>C_{i}</math> (на первом шаге - первый). Если все кластеры просмотрены, идем в пункт 6;
3. Берем следующий кластер <math>C_{j}, i<>j</math>. Если все кластеры просмотрены, то идем в пункт 2;
4. Проверяем смежность <math>C_{i}</math> и <math>C_{j}</math>. Если не смежны, то возвращаемся в пункт 3. Если смежны, идем в пункт 5;
5. Рассчитываем показатели <math>RI_{(C_{i},C_{j})}</math> и <math> RC_{(C_{i},C_{j})}</math>. Проверяем, удовлетворяют ли найденные значения условиям:
*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>
*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>
Если нет, то идем в пункт 3. Иначе если смежность пары кластеров выше, чем у предыдущих найденных, то <math>F_{i}=j</math>. Идем в пункт 3;
6. Если в списке F есть хотя бы одна пара кластеров для слияния, то выполняем слияние, обновляем массив кластеров и массив объединений кластеров. Идем в пункт 2.

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

1) Для построения графа на основе метода k ближайших соседей для n вершин требуется <math>O(n log(n))</math> операций <ref>J.H. Friedman, J.L. Bentley, and R.A. Finkel. An algorithm for ﬁnding best matches in logarithmic expected time. ACM Transactions on Mathematical Software, 3:209–226, 1977.</ref>; для наборов данных большой размерности эта величина составляет <math>O(n^2)</math> операций <ref>S. Berchtold, C. Bohm, D. Keim, and H.-P. Kriegel. Cost model for nearest neighbor search in high dimensional data space. In Proc. of Symposium on Principles of Database Systems, Tucson, Arizona, 1997.</ref>;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций, где <math>m</math> - количество подграфов, полученных на втором этапе алгоритма;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, для n вершин получаем последовательную сложность <math>O(n log(n)+nm+m^2log(m))</math>.

== Информационный граф ==
[[File:СК.png]]

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

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

Второй и третий этапы можно распараллелить частично.

Второй этап распараллеливается путем подачи на вход свободному процессу очередного подграфа для разделения. Число итераций оценивается в <math>O(n log(n))</math>.

Третий этап делится на расчет показателей схожести и соединение подграфов в кластеры. Процесс расчета показателей можно распараллелить, подавая каждому процессу на вход пару подграфов. Сложность этого процесса оценивается как <math>m log(m)</math>. Соединение подграфов в кластеры выполняется последовательно, сложность процесса составляет <math>m^2 log(m)</math>

Таким образом получаем общую параллельную сложность алгоритма: <math>O(n+ n log(n) + m^2 log (m) + m log(m))</math>

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

1. Симметрическая матрица <math>A</math> расстояний между элементами данных размера <math>n\times n</math> с нулями на главной диагонали (<math>a_{ii}= 0, i = 1, \ldots, N</math>).

2. <math>k</math> - количество ближайших соседей для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3. <math>l</math> - наименьшее число вершин, которое может содержать наибольший подкластер на 2-м этапе . Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

'''Объём входных данных'''

<math>\frac{n (n - 1)}{2}</math> (в силу симметричности и нулевой главной диагонали достаточно хранить только над/поддиагональные элементы).

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

Вектор из <math>n</math> чисел <math>u_{1}, u_{2}, \ldots, u_{N}</math>, где <math>u_{i}</math> - целое число, соответствующее кластеру <math>i</math>-го объекта.

'''Объём выходных данных'''

<math>n</math>

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности на первом этапе является ''линейным'' для больших наборов данных и логарифмическим для n вершин. На втором этапе сложно оценить это соотношение - оно сильно зависит от параметров <math>k</math> и <math>l</math>. На третьем этапе соотношение равно <math>O(1)</math>;

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

<math>O(1)</math> для 1-го этапа;

<math>O(\frac{nm}{n^2+m^2})</math> для 2-го этапа;

<math>O(\frac{m^2log(m)}{m^2+n})</math> для 3-го этапа;

Алгоритм является ''недетерминированным''. Хотя 1-й этап детерминирован, на 2-ом этапе могут быть найдены различные разбиения на подграфы, что повлияет и на итоговый результат работы алгоритма.

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

Масштабируемость исследовалась на основе работы, презентующей пробную версию параллельной реализации алгоритма для различного числа потоков<ref>http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.
График показывает, что эффективность и скорость работы алгоритма растут с увеличением объема входных данных. Однако, в упомянутой выше работе отмечается, что эффективность алгоритма падает с ростом количества потоков.

[[File:Масштабирование.png|700px|center]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Последовательная реализация алгоритма доступна по ссылке <ref>http://read.pudn.com/downloads36/sourcecode/math/115779/chameleon/chameleon.c__.htm</ref>.

CHAMELEON можно реализовать с использованием графовых библиотек METIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/metis/overview
</ref>, hMETIS <ref>http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref>https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, оно было рассмотрено в пункте 2.4.

Параллельных реализаций алгоритма CHAMELEON не найдено.

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

Участник:Артем Таран/Графо-ориентированный алгоритм кластеризации CHAMELEON

2016-11-29T14:31:41Z

Kronberg:

{{Assignment|Algoman|Kronberg}}

{{algorithm
| name = Графо-ориентированный алгоритм кластеризации CHAMELEON
| serial_complexity = <math>O(n^2+nm+m^2log(m))</math>
| pf_height = <math>O(n + log(n) + mlog(m) + m^2log(m))</math>
| pf_width = <math>O(n)</math>
| input_data = <math>\frac{n (n - 1)}{2}</math>
| output_data = <math>n</math>
}}

Статью подготовили: [[Участник:Артем_Таран|Артём Таран Иванович]] (разделы 1.1 - 1.10, 2.7), [[Участник:ShimchikN|Шимчик Никита Владимирович]] (разделы 1.1 - 1.10, 2.7).
== Свойства и структура алгоритма ==

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

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

Графо-ориентированный алгоритм кластеризации CHAMELEON<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref> - алгоритм, который измеряет сходство двух кластеров на основе
динамической модели. В процессе кластеризации два кластера объединяются, только если показатели взаимосвязанности и близости между двумя кластерами являются высокими по отношению к показателям внутренней взаимосвязанности кластеров и близости элементов внутри этих кластеров. Процесс слияния с использованием динамической модели, использующийся в данном алгоритме облегчает открытие
природных и однородных кластеров. Методология динамического моделирования кластеров, использующаяся в CHAMELEON,
применима ко всем типам данных, для которых может быть построена матрица подобия.

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

Алгоритм кластеризации CHAMELEON включает в себя три этапа:

1) Построение графа, путём добавления рёбер по принципу k ближайших соседей.

2) Выделение множества сравнительно малых связных подграфов.

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе.

[[Файл:Графы k ближайших соседей.jpg|1000px|thumb|center|Графы k ближайших соседей: 1) объекты в пространстве, 2) граф по принципу 1-го ближайшего соседа, 3) граф по принципу 2-го ближайшего соседа, 4) граф по принципу 3-х ближайших соседей<ref name="rt">http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf</ref>]]

=== Математическое описание алгоритма ===
==== Данные ====
* '''Исходные данные''': множество из <math>n</math> точек <math>V = \{v_{i}\}</math> в метрическом пространстве, которое может быть задано в виде треугольной матрицы расстояний <math>A</math> размера <math>n\times n</math>; натуральное число <math>k</math>, используемое в качестве параметра алгоритма поиска k ближайших соседей.

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

* '''Промежуточный результат после второго этапа''': разбиение множества <math>V</math> на набор <math>K = \{K_{i}\}</math> попарно непересекающихся связных подмножеств, из которого образуется взвешенный граф <math>G_{2} = (K, E_{2})</math>.

* '''Промежуточный результат после третьего этапа''': итоговое разбиение множества вершин графа <math>G_{2}</math> на набор кластеров <math>C = \{C_{i}\}</math>.

* '''Вычисляемые данные''': n-мерный вектор <math>v</math> (элементы <math>v_{i}</math>), показывающий отображение исходного множества точек на набор кластеров <math>C</math>.

==== Определения ====

* ''Абсолютная взаимная связность между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как сумма весов ребер, соединяющих вершины, принадлежащие <math>C_{i}</math> с вершинами из <math>C_{j}</math>. Эти ребра, фактически, входят в разделитель ребер графа, состоящего из кластеров <math>C_{i}</math> и <math>C_{j}</math>, и разбивающим его на подграфы <math>C_{i}</math> и <math>C_{j}</math>. Обозначается эта величина как
<math>EC_{(C_{i},C_{j})}</math>. Внутреннюю связность <math>EC_{C_{i}}</math> кластера <math>C_{i}</math> можно вычислить как сумму ребер, входящих в разделитель ребер, разбивающий <math>C_{i}</math> на два совершенно равных подграфа.

* ''Относительная взаимная <math>RI_{(C_{i},C_{j})}</math> связность пары кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется формулой:

<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math>

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

* ''Абсолютное взаимное сходство между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' подсчитывается как среднее сходство между соединенными вершинами, принадлежащими <math>C_{i}</math> и <math>C_{j}</math> соответственно. Эти соединения обусловлены предыдущим разбиением общего графа, полученного на матрице сходства.

* ''Относительное взаимное сходство <math>RC_{(C_{i},C_{j})}</math> между парой кластеров <math>C_{i}</math> и <math>C_{j}</math>'' определяется как абсолютное сходство между этой парой кластеров, нормализованное с учетом их внутреннего сходства и вычисляется по формуле:

<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math>,

где <math>S_{EC_{(C_{i})}}</math> и <math>S_{EC_{(C_{i})}}</math> - средние веса ребер (значения сходства), принадлежащих разделителю ребер кластеров <math>C_{i}</math> и <math>C_{j}</math> соответственно,
и <math>S_{EC_{(C_{i},C_{j})}}</math> - средний вес ребер, соединяющих вершины <math>C_{i}</math> с вершинами <math>C_{j}</math>, причем ребра принадлежат разделителю ребер <math>EC_{(C_{i})}</math>, определенному ранее.

Далее, алгоритм применяет агломеративную иерархическую кластеризацию с использованием вышеозначенных показателей. Причем существует две стратегии их учета. Первая подразумевает наличие некоторых пороговых значений <math>T_{RI}</math> и <math>T_{RC}</math>. В соответствии с этой стратегией, алгоритм для каждого кластера <math>C_{i}</math> проверяет, отвечают ли смежные (наиболее близкие) ему кластеры условиям:

*<math>RI_{(C_{i},C_{j})} \geqslant T_{RI}</math>

*<math>RC_{(C_{i},C_{j})} \geqslant T_{RC}</math>

Если более одного смежного кластера отвечает этим условиям, то алгоритм выбирает для объединения наиболее связный кластер (граф), то есть такой кластер <math>C_{j}</math>, с которым у кластера <math>C_{i}</math> получается наибольшая абсолютная взаимная связность. По завершению прохода по всем кластерам, созданные таким образом пары объединяются. Параметры <math>T_{RI}</math> и <math>T_{RC}</math> могут использоваться для изменения характеристик получаемых кластеров.

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

<math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>,

где <math>\alpha</math> выбирается пользователем. Если <math>\alpha > 1 </math>, то алгоритм придает большее значение относительному взаимному сходству, а если <math>\alpha < 1 </math>, то большее значение имеет относительная взаимная связность. Разумеется, данный подход позволяет получить полную дендрограмму кластерного анализа<ref name="rty">http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html</ref>.

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

На первом этапе работы алгоритма вычислительным ядром можно считать процесс нахождения k ближайших соседей для каждой отдельной вершины.

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

На третьем этапе работы алгоритма вычислительным ядром является расчёт <math>EC_{(C_{i},C_{j})}</math>, <math>RC_{(C_{i},C_{j})}</math> и <math>RI_{(C_{i},C_{j})}</math> для пары смежных кластеров, а также их слияние.

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

Алгоритм CHAMELEON выполняется в 3 этапа, последовательных относительно друг друга. Каждый этап соответствует отдельному алгоритму.

* Макрооперацией на первом этапе является процедура выделения k ближайших соседей.

* Макрооперацией на втором этапе является процедура разбиения наибольшего подграфа на каждой итерации.

* Макрооперациями на третьем этапе являются процедуры вычисления метрики для принятия решения об объединении кластеров и объединение кластеров на каждой итерации.

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

* Первый этап (псевдокод):
integer n; // Количество точек.
integer k; // Параметр k
integer A[n][n]; // Верхняя треугольная матрица расстояний между точками.

integer E[n][n]; // Верхняя треугольная матрица рёбер графа G - изначально инициализирована нулями.
foreach (integer i in (1,n-1) ) {
integer Neighbours[k]; // матрица, используемая хранения ближайших соседей
integer countN = 0;

foreach (integer j in (i+1, n) ) {
// Заполняем матрицу Neighbours, добавляя новые элементы и увеличивая счётчик countN.
// Когда countN станет равен k, новые элементы будут вставляться на место старых, либо отбрасываться.
}

foreach (integer j in (0, countN) ) {
E[min(i,j), max(i,j)] = 1;
}
}
return E;

* Второй этап:
[[File:Диаграмма_шаг_2.png]]

* Третий этап:
[[File:Chameleon_stage_3.png|611px]]

=== Последовательная сложность алгоритма ===
1) Построение графа на основе метода k ближайших соседей в худшем случае требует <math>O(n^2)</math> операций;

2) Для выделения множества сравнительно малых связных подграфов требуется <math>nm</math> операций;

3) Формирование набора кластеров, на основе множества подграфов, полученных на предыдущем этапе, требует <math>m^2log(m)</math> операций.

Итого, получаем последовательную сложность <math>O(n^2+nm+m^2log(m))</math>.

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

[[File:Chameleon_inforgraph.png|811px]]

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

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

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

На третьем этапе можно распараллелить процесс расчёта метрик сходства между кластерами, однако итоговое слияние всё равно должно выполняться последовательно.
Поскольку процесс сравнения кластеров возможно распараллелить, сложность 3-го этапа составляет <math>mlog(m) + m^2log(m)</math>.

Таким образом, суммарная параллельная сложность оказывается равна <math>O(n + log(n) + mlog(m) + m^2log(m))</math>.

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

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

1) Треугольная матрица <math>A</math> размера <math>n\times n</math> (где n — количество объектов), в которой элементу <math>a_{ij}</math> соответствует расстояние между i-м и j-м объектами.

2) Количество ближайших соседей <math>k</math> для вершин (рекомендуемое значение <math>k</math> от 5 до 20 в зависимости от количества анализируемых объектов).

3) Наименьшее число вершин, которое может содержать наибольший подграф на 2-м этапе <math>l</math>. Величина этого параметра варьируется от 1 до 5 % от общего числа объектов.

* Объём входных данных: <math>\frac{n (n - 1)}{2}</math>

* Выходные данные: n-мерный вектор <math>v</math>, в котором элементу <math>v_{i}</math> соответствует номер кластера, присвоенный i-му объекту

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

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

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

У второго и третьего этапов алгоритма сложно полностью оценить ресурсы параллелизма. Но оба этапа возможно частично распараллелить.

'''Вычислительную мощность''' для разных этапов алгоритма можно оценить как:

1 этап: <math>O(1)</math>

2 этап: <math>O(\frac{nm}{n^2+m^2})</math>

3 этап: <math>O(\frac{m^2log(m)}{m^2+n})</math>

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

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

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

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

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

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

Проводилось исследование масштабируемости экспериментальной версии параллельной реализации алгоритма для малого числа потоков<ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

Его результаты отражены на графиках. Из графиков видно, что ускорение и эффективность алгоритма растут с увеличением объема данных.

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

[[File:Plot cham.jpg|850px|center]]

[[File:Cham_speedup.png]] [[File:Cham_eff.png]]

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

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

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

Существует несколько последовательных реализаций алгоритма. С одной из них можно ознакомиться по ссылке <ref name="tra">http://www.codeforge.com/article/192925</ref>.

Возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, как, например METIS <ref name="tru">http://glaros.dtc.umn.edu/gkhome/metis/metis/overview</ref> , hMETIS <ref name="tri">http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview</ref> и RANN <ref name="tro">https://cran.r-project.org/web/packages/RANN/index.html</ref>.

Параллельных реализаций алгоритма CHAMELEON найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь <ref name="tr">http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf</ref>.

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

<references \>

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-29T14:29:53Z

Kronberg:

{{Assignment|Algoman|Kronberg}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy Лазовский Р. А.] (разделы 1.1 - 1.4 , 1.7 , 1.8),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87 Мустафаев Э. Э.] (разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2)

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики (простейший пример — евклидова метрика). Не следует путать задачу кластеризации с задачей классификации: в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик (возможные метрики будут подробно описаны далее). Число получаемых в итоге кластеров в явном виде не задаётся.

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

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math>, возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа (т.е. объекты), а <math>E</math> - множество ребер графа (т.е. построенные связи между ближайшими соседями). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> (имеется ввиду количество вершин) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> (имеется ввиду количество вершин). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

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

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

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

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

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

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

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

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

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

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений (для вычисления квадратичной нормы разности векторов).

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

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON (см. раздел "Существующие реализации"). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

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

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

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

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

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

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

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

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

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

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

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

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью, включающий в себя значительную модификацию исходного алгоритма, но не приводится рабочая реализация.

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

Для исследования такой масштабируемости вширь использовалась референсная последовательная реализация алгоритма (cм. раздел "Существующие реализации"). Соответствующая программа запускалась на системе BG/P на одном вычислительном узле. Характеристики вычислительного узла, а также микропроцессорного ядра - элемента такого узла, приводятся в <ref>http://hpc.cmc.msu.ru/bgp</ref> Таким образом, удостоверенными экспериментальными данными являются только значения, полученные для случая 1 процесса. Значения для случаев 2 и 4 процессов являются ОЦЕНОЧНЫМИ и выводятся из результатов работы модифицированной версии алгоритма, исследуемой в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. К сожалению, указанной реализации авторы не предоставляют.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Теоретически возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

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

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Участник:JuliaA/Алгоритм кластеризации с использованием представлений

2016-11-29T14:27:20Z

Kronberg:

Основные авторы описания: 
[[Участник:JuliaA|Ю.А. Антохина]], разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]] - [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]] 

[[Участник:Cookie|С.А. Шатков]], разделы [[#Математическое описание алгоритма|1.2]] - [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Масштабируемость алгоритма и его реализации|2.4]] 

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

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

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

Результат кластеризации зависит от того, как будут представлены кластеры. Например, средним всех точек кластера, или всеми точками кластера. Применение среднего возможно только в евклидовом пространстве. А использование всех точек неустойчиво к случайным выбросам. В CURE используется другой метод: для каждого кластера выбираются точки-представители. Выбирается постоянное число точек, которые будут представлять каждый кластер. Кластеры с наиболее похожими наборами репрезентативных точек объединяются на каждом шаге алгоритма.

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

Описание шагов

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

'''Шаг 2'''. Для каждого кластера выбираем <math>c</math> точек-представителей, максимально удаленных друг от друга. Чисто <math>c</math> остается постоянным.

'''Шаг 3'''. Объединяем кластеры с наиболее похожими наборами точек-представителей.
Если не достигнуто нужное число кластеров, то перейти на шаг 2.
Чтобы при объединении кластеров не выбирать каждый раз c точек-представителей из всех точек, мы выбираем их только из <math>2c</math> точек объединенных кластеров.

Выбранные точки сдвигаются на следующем шаге на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Exampleofalgorithmparametrs1.png|600px|thumb|center|Пример работы алгоритма для разных параметров <math>\alpha</math> [1].]]

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

Пусть дана матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек-представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>. Каждая строка матрицы представляет собой точку в <math>n</math> - мерном пространстве.

m число точек для кластеризации, n размерность.

Расстояние <math>\rho(a,b)</math> между точками <math>a = (a_{1},\dots,a_{n})</math> и <math>b = (b_{1},\dots,b_{n})</math> будем вычислять по формуле:

<math>\rho(a,b) = \sqrt{\sum_{i=1}^n (a_{i} - b_{i})^2}</math>

'''Шаг "Инициализация"'''

Выбираются <math>\lceil \gamma m\rceil</math> строк матрицы случайным образом. Например, можно использовать [https://ru.wikipedia.org/wiki/Reservoir_sampling Алгоритм R].

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

'''Шаг "Кластеризация"'''

В самом начале шага считаем каждую выбранную точку одноточечным кластером с центроидой в этой же точке.

Далее выполняем следующие шаги 1-2, пока количество кластеров не станет равно <math>h</math>:

Шаг 1:

Для каждого <math>i</math>-го кластера вычисляется центроида <math>\mu_{i}</math> по формуле:

<math>\mu_{i} = \frac{1}{s_{i}}\sum_{j\in S_{i}} x^{j}</math>, где <math>S_{i}</math> - номера строк матрицы <math>x</math>, входящие в <math>i</math>-й кластер; <math>s_{i}</math> - количество элементов в множестве <math>S_{i}</math>; <math>x^{j}</math> - <math>j</math>-я строка матрицы <math>x</math>.

Шаг 2:

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

'''Шаг "Назначение представителей"'''

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

Для этого используем следующий алгоритм:

Пусть <math>i</math> - текущее количество представителей, <math>S_{k}</math> - множество номеров строк матрицы <math>x</math>, входящие в <math>k</math>-й кластер, <math>R_{k}</math> - множество номеров строк матрицы <math>x</math>, назначенных представителями <math>k</math>-го кластера, а <math>x^{j}</math> - вектор-строка матрицы <math>x</math>, задающая точку в <math>n</math>-мерном пространстве.

<math>R_{k}</math> = [] % Пустое множество
a = Choose(<math>S_{k}</math>) % Выбор произвольного номера точки, входящей в кластер <math>k</math>
Add(<math>R_{k}</math>,a) % Добавление точки а во множество представителей
i = 1 % Текущее количество представителей кластера
While (i<c) do % Хотим найти с представителей для кластера
- rmax = 0
- For ( (y <math>\in</math> <math>S_{k}</math>) and (y <math>\notin</math> <math>P_{k}</math>) ) do % Поиск следующего представителя среди оставшихся точек кластера
- - rmin = <math>\rho(x^{a}</math>,<math>x^{y})</math>
- - For ( (j <math>\in</math> <math>R_{k}</math>) and (j <math>\neq</math> a) ) do % Поиск расстояния от точки с номером y до ближайшего представителя
- - - d = <math>\rho(x^{j}</math>,<math>x^{y})</math> % вычисление расстояния
- - - If (d < rmin) then
- - - - rmin = d
- - - endif
- - enddo
- - If (rmin > rmax) % Поиск точки, для которой расстояние до ближайшего представителя является максимальным
- - - rmax = rmin
- - - b = y % искомая точка
- - endif
- enddo
- Add(<math>R_{k}</math>,b) % Добавление новой точки в множество представителей
- i = i + 1 % текущее число представителей
enddo
</math>

'''Шаг "Сдвиг представителей к центроиде"'''

Для каждого представителя <math>x^{y}</math> из <math>k</math>-го кластера выполняется сдвиг к его центроиде <math>\mu_{k}</math> в <math>\alpha</math> раз:

<math>\hat{x}^{y} = \alpha\mu_{k} + (1-\alpha)x^{y}</math>.

Получаем множество <math>\hat{R}_{k}</math> из <math>c</math> точек, которые будут далее использоваться как представители этого кластера.

'''Шаг "Присваивание"'''

На данном шаге происходит присвоение неиспользованных точек (строк матрицы <math>x</math>) к кластерам. Для точки-строки <math>p</math> вычисляется расстояние до каждого представителя. Результат: строка <math>p</math> добавляется в поддерево кластера, которому принадлежит наиближайший представитель.

Результатом работы алгоритма является дерево, ветвями которого являются отдельные кластеры. Листьями кластеров являются строки из матрицы <math>x</math>.

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

Вычислительное ядро алгоритма представляет собой итерационное построение <math>k</math> кластеров с помощью иерархического метода, вычисление их центроид <math>\mu_{k}</math> и назначение точек-представителей. В ходе работы вычислительного ядра формируется дерево, в котором точки, выбранные на этапе '''Инициализации''' собраны в <math>h</math> поддеревьев. Точки-представители хранятся в отдельной структуре. Эти точки будут использованы для выбора кластеров для неиспользованных (на этапе '''Инициализации''') точек после работы вычислительного ядра.

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

Задача алгоритма кластеризации состоит в формировании <math>h</math> кластеров из <math>m</math> точек; число <math>h</math> задано заранее.

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

После этого происходит назначение точек-представителей для каждого кластера и их сдвиг к центроиде.

Далее для неиспользованных точек <math>x</math> происходит вычисление расстояний до всех точек-представителей. Точка помещается в тот кластер, точка-представитель которого находится ближе остальных.

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

[[Файл:SubCURE4.jpg|1100px|thumb|center|Схема работы алгоритма кластеризации CURE]]

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

Входные данные для кластеризации - это <math>n</math> репрезентативных точек в d мерном пространстве и необходимое число <math>h</math> кластеров. Для каждой точки необходимо вычислить расстояние до другой. Сложность этого этапа <math>O(n)</math>. Если искать ближайший кластер простым перебором, то сложность поиска будет <math>O(n)</math> для каждого кластера. Но для эффективного поиска сложность составляет <math>log_2{n}</math>. Эффективный метод описан в статье.<ref>Sudipto Guha (Stanford), Rajeev Rastogi (Bell Labs), Kyuseok Shim (Korea Institute of Technology). CURE: an efficient clustering algorithm for large databases. SIGMOD '98 Proceedings of the 1998 ACM SIGMOD international conference on Management of data, pp 73-84 </ref> Далее каждую точку необходимо вдвинуть к центроиде, сложность этой операции <math>O(2)</math>.
Таким образом худшее время выполнения алгоритма <math>O(n^2 log_2{n})</math>. Для двумерного пространства временная сложность может быть <math>O(n^2)</math>. Так что сложность алгоритма не хуже чем у центроидного. То есть при такой размерности входных данных CURE выполняется за полиномиальное время.<math>~^{[1]}</math>

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

'''Шаг "Инициализация"'''

В зависимости от алгоритма случайная выборка номеров строк матрицы <math>x</math> может производится либо зависимо, либо независимо друг от друга.

'''Шаг "Кластеризация"'''

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

'''Шаг "Назначение представителей"'''

[[Файл:Points c.png|800px|thumb|center|Последовательный информационный граф для точек-представителей]]

'''Шаг "Сдвиг представителей к центроиде"'''

Данный шаг выполняется независимо для каждой точки-представителя каждого кластера.

'''Шаг "Присваивание"'''

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

Основные шаги алгоритма информационно зависят от предыдущих шагов.

[[Файл:InfoCURE.jpg|1100px|thumb|center|Общий информационный граф алгоритма. В прямоугольниках - шаги алгоритма, в эллипсах - данные.]]

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

'''Шаг "Кластеризация"'''

Шаг 1 (вычисление центроид):

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

Шаг 2 (поиск "наилучших кластеров для объединения):

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

'''Шаг "Назначение представителей"'''

Представители внутри каждого кластера определяются независимо от других кластеров и поддаются распараллеливанию.

'''Шаг "Сдвиг представителей к центроиде"'''

Изменение положения представителей можно сделать независимо как от представителей данного кластера, так и представителей других кластеров. Это также хорошо поддаётся распараллеливанию.

'''Шаг "Присваивание"'''

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

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

Входные данные: матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>.

<math>m</math> число точек для кластеризации, <math>n</math> размерность.

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

Параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной выборке точек на шаге "Инициализация". Слишком малое значение <math>\gamma</math> может привести к объединению удалённых кластеров (если ни одна из точек предполагаемого кластера не была выбрана, они были присоединены к другому кластеру на этапе присваивания), а также к разделению кластеров на части (так как конечное количество кластеров фиксировано, а некоторые кластеры могут не набрать достаточное количество мест в выборке, чтобы их кластер сформировался). С другой стороны, скорость вычислений зависит от величины выборки: увеличение выборки при фиксированном числе кластеров <math>h</math> приведёт к дополнительным шагам на этапе кластеризации, а также к дополнительным вычислениям при нахождении кластеров, "наиболее подходящих" для объединения на каждом шаге. Кроме того, увеличение выборки приводит к уменьшению числа оставшихся точек, присвоение которых не входит в [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

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

Число точек представителей выбирается в зависимости от данных. Если возможно появление кластеров сложной формы, то точек должно быть больше, чтобы выявить их форму. В оригинальной статье авторы показывают что уже при <math>c</math> равном <math>10</math> достигается неплохая эффективность, в то время как при <math>c = 5</math> большой кластер был разделён на несколько частей.

[[Файл:Exampleofalgorithmparameters2.png|400px|thumb|center|Пример работы алгоритма для разных параметров <math>c</math>.]]

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

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

Состав выходного дерева:

- <math>m</math> листьев (векторов из <math>R^{1 \times n}</math>);

- вершины-кластеры представляют собой массивы указателей на листья (число таких указателей равно <math>m</math>);

- корень представляет собой массив указателей на вершины-кластеры (число таких указателей равно числу кластеров <math>h</math>);

- также имеется указатель на корень дерева.

'''Объём выходных данных:''' <math>m\times n + kp*(m + h + 1)</math>, где <math>kp</math> - коэффициент, равный отношению размера элемента из <math>R</math> к размеру указателя, зависящему от архитектуры платформы.

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

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

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

'''Недостатки''': есть необходимость в задании пороговых значений и количества кластеров, работает только на числовых данных, эффективен только для данных низкой размерности

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

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

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

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

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

Увы

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

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

== Существующие реализации алгоритма ==
Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике <ref>Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP</ref>. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

<references \>

Участник:Лукьянова Анна/Алгоритм кластеризации с использованием представлений2

2016-11-29T14:27:04Z

Kronberg:

Основные авторы описания: [[U:Лукьянова Анна|А.Я. Лукьянова]]

= ЧАСТЬ. Свойства и структура алгоритмa =
== Общее описание алгоритма ==

===Понятие кластеризации===

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

Применение кластерного анализа в общем виде сводится к следующим этапам:

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

'''Классификация алгоритмов'''

'''Методы по способу обработки данных:'''

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

*Агломеративные методы AGNES (Agglomerative Nesting) - характеризуются последовательным объединением исходных элементов и соответствующим уменьшением числа кластеров. В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор,
пока все объекты не будут составлять один кластер.

*Дивизимные методы DIANA (Divisive Analysis) - характеризуются последовательным разделением исходного кластера, состоящего из всех объектов, и соответствующим увеличением числа кластеров. В начале работы алгоритма все объекты принадлежат одному кластеру, который на последующих шагах делится на меньшие кластеры, в результате образуется последовательность расщепляющих групп.

''Неиерархические методы:'' строят одно разбиение объектов на кластеры.
*Итеративные

'''Алгоритмы по способу анализа данных:'''

*''Четкие'' (непересекающиеся) алгоритмы каждому объекту выборки ставят в соответствие номер кластера, т.е. каждый объект принадлежит только одному кластеру;

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

'''Методы по количеству применений алгоритмов кластеризации:'''

*С одноэтапной кластеризацией;

*С многоэтапной кластеризацией.

'''Методы по возможности расширения объема обрабатываемых данных:'''

*Масштабируемые;

*Немасштабируемые

'''Методы по времени выполнения кластеризации:'''

*Потоковые (on-line);

*Не потоковые (off-line).

===CURE===

Алгоритм '''CURE (Clustering Using REpresentatives)''' выполняет иерархическую кластеризацию с использованием набора определяющих точек для определения объекта в кластер. Относится к алгомеративным методам.

''Назначение'': кластеризация очень больших наборов числовых данных.

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

''Недостатки'': есть необходимость в задании пороговых значений и количества кластеров.

Описание алгоритма :

[[file:Page1.png|thumb|center|1400px|Рисунок 1: Обзор CURE ]]

'''Шаг 1:''' Построение дерева кластеров, состоящего из каждой строки входного набора данных.

'''Шаг 2:''' Формирование «кучи» в оперативной памяти, расчет расстояния до ближайшего кластера (строки данных) для каждого кластера. При формировании кучи кластеры сортируются по возрастанию дистанции от кластера до ближайшего кластера. Расстояние между кластерами определяется по двум ближайшим элементам из соседних кластеров. Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

'''Шаг 3:''' Слияние ближних кластеров в один кластер. Новый кластер получает все точки входящих в него входных данных. Расчет расстояния до остальных кластеров для новообразованного кластера. Для расчета расстояния кластеры делятся на две группы: первая группа – кластеры, у которых ближайшими кластерами считаются кластеры, входящие в новообразованный кластер, остальные кластеры – вторая группа. И при этом для кластеров из первой группы, если расстояние до новообразованного кластера меньше чем до предыдущего ближайшего кластера, то ближайший кластер меняется на новообразованный кластер. В противном случае ищется новый ближайший кластер, но при этом не берутся кластеры, расстояния до которых больше, чем до новообразованного кластера. Для кластеров второй группы выполняется следующее: если расстояние до новообразованного кластера ближе, чем предыдущий ближайший кластер, то ближайший кластер меняется. В противном случае ничего не происходит.

'''Шаг 4:''' Переход на шаг 3, если не получено требуемое количество кластеров.

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

Прежде всего, алгоритм использует случайное разбиение выборки из <math> s </math> элементов на <math> p </math> частей, которые могут поместиться в память отдельной машины кластера. Затем во время первого прохода алгоритм уменьшает число кластеров в каждой подвыборке до <math> \frac{s}{pq} </math>, где <math> q \geq 1 </math> – некоторая константа (происходит объединение ближайших кластеров). Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

''Метрика Евклида:'' <math>\rho(p,k) = \sqrt{\sum_{i=1}^n (p_{i} - k_{i})^2}</math>

''«Манхеттенская» метрика:'' <math>\rho(p,k) =\sum_{i=1}^n |p_{i} - k_{i}|</math>

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

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

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

[[Файл:Param_c.png|400px|thumb|center| Рисунок 2: Результат работы алгоритка в зависимости от количесва представлений <math>c</math>.]]

Из рисунка видно, что при меньших значениях <math>c</math> качество работы алгоритма ухудшается

Выбранные точки сдвигаются на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Factor_a.png|400px|thumb|center| Рисунок 3: Чувствительность алгоритма к параметру <math>\alpha </math>.]]

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

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

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

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

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

Входные параметры: набор входных данных <math>S</math>, содержащий <math>m</math> точек в <math>n</math>-мерном пространстве
и требуемое количество кластеров <math>k</math>. Начиная с отдельных точек в виде отдельных кластеров, на каждом шаге ближайшая пара кластеров объединяются, чтобы сформировать новый кластер.Процесс повторяется до тех пор, пока не достигнет <math>k</math>.

'''procedure''' cluster(S,k)
'''begin'''
1. T:=build_kd_tree(S)
2. Q:-build_heap(S)
3. '''while''' size(Q)>k '''do''' {
4. u:=extract_min(Q)
5. v:= u.closest
6. delete(Q, V)
7. w := merge(u,v)
8. delete_rep(T, u); delete_rep(T, v); insert_rep(T, w)
9. w.closest := x /* x is an arbitrary cluster in Q */
10. '''for each''' x \in Q'''do''' {
11. '''if''' dist(w, x) < dist(w, w.closest)
12. w.closest := x
13. '''if''' x.closest is either u or w {
14. ''' if''' dist(x, x.closest) < dist(x, w)
15. x.closest := closest_cluster(T, x, dist(x, w))
16. '''else'''
17. x.closest := w
18. relocate(Q, x)
19. }
20. '''else if''' dist(x, x.closest) > d&(x, w) {
21. x.closest := w
22. relocate(Q, x)
23. }
24. }
25. insert(Q, w)
26. }
'''end'''

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

Являясь представителем иерархических алгоритмов кластеризации, имеет сложность <math> O(n^2 log(n)) </math> и <math> O(n^2) </math> для признаковых пространств малой размерности

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

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

[[Файл:Metod.png|400px|thumb|center| Рисунок 4: Дендрограмма агломеративных методов]]

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

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

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

'''Входные данные:''' набор данных <math> S </math> , количество кластеров <math>k</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>q</math>, <math>p</math> число разбиений выборки, <math>n</math> размерность.

Параметр <math>\alpha</math> для сжатия точек представления к центру кластера.

'''Выходные данные:''' требуемое количество <math> k </math> крастеров

===Оптимальный выбор параметров для алгоритма===

*размер случайной выборки <math> S </math> (''а'')

При запуске CURE со случайными размерами выборки в пределах от 500 до 5000 видно, что при размерах до 2000 были найдены кластеры низкого качества, начиная с 2500 точек и выше (2,5% от установленного размера данных), CURE всегда правильно определяет кластеры.

*число точек представителей <math> c </math> (''b'')
В оригинальной статье авторы показывают что уже при <math> c </math> равном <math>10</math> достигается неплохая эффективность.

*число разбиений выборки <math> p </math> ('''c''')
<math> p </math> должно быть выбрано таким, что <math> \frac{s}{pq} </math> > <math> k </math>

*размерность (''d'')
CURE хорошо себя чувствует при больших размерностях

*сжимающий фактор <math>\alpha</math>
В оригинальной статье авторы показывают что <math>\alpha</math> от 0.2 до 0.7 помогает хорошо выявлять несферические кластеры и подавлять редкие выбросы.

[[Файл:4pic.png|800px|thumb|center| Рисунок 5: Влияние параметров <math> S </math>, <math> c </math>, <math> p </math> и размерности на работу алгоритма.]]

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

* является масштабируемым алгоритмом

* неважна форма кластера и размер

*работает только на числовых данных

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

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

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

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

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

будет..

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

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

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

Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике [4]. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Theodoridis, Sergios; Koutroumbas, Konstantinos (2006). Pattern recognition. Academic Press. pp. 572–574. ISBN 978-0-12-369531-4.

[3] Guha, Sudipto; Rastogi, Rajeev; Shim, Kyuseok (2001). "CURE: An Efficient Clustering Algorithm for Large Databases" (PDF). Information Systems. 26 (1): 35–58. doi:10.1016/S0306-4379(01)00008-4

[4] Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP

Участник:Лукьянова Анна/Алгоритм кластеризации с использованием представлений2

2016-11-29T14:26:28Z

Kronberg:

{{Assignment|Kronberg}}

Основные авторы описания: [[U:Лукьянова Анна|А.Я. Лукьянова]]

= ЧАСТЬ. Свойства и структура алгоритмa =
== Общее описание алгоритма ==

===Понятие кластеризации===

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

Применение кластерного анализа в общем виде сводится к следующим этапам:

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

'''Классификация алгоритмов'''

'''Методы по способу обработки данных:'''

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

*Агломеративные методы AGNES (Agglomerative Nesting) - характеризуются последовательным объединением исходных элементов и соответствующим уменьшением числа кластеров. В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор,
пока все объекты не будут составлять один кластер.

*Дивизимные методы DIANA (Divisive Analysis) - характеризуются последовательным разделением исходного кластера, состоящего из всех объектов, и соответствующим увеличением числа кластеров. В начале работы алгоритма все объекты принадлежат одному кластеру, который на последующих шагах делится на меньшие кластеры, в результате образуется последовательность расщепляющих групп.

''Неиерархические методы:'' строят одно разбиение объектов на кластеры.
*Итеративные

'''Алгоритмы по способу анализа данных:'''

*''Четкие'' (непересекающиеся) алгоритмы каждому объекту выборки ставят в соответствие номер кластера, т.е. каждый объект принадлежит только одному кластеру;

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

'''Методы по количеству применений алгоритмов кластеризации:'''

*С одноэтапной кластеризацией;

*С многоэтапной кластеризацией.

'''Методы по возможности расширения объема обрабатываемых данных:'''

*Масштабируемые;

*Немасштабируемые

'''Методы по времени выполнения кластеризации:'''

*Потоковые (on-line);

*Не потоковые (off-line).

===CURE===

Алгоритм '''CURE (Clustering Using REpresentatives)''' выполняет иерархическую кластеризацию с использованием набора определяющих точек для определения объекта в кластер. Относится к алгомеративным методам.

''Назначение'': кластеризация очень больших наборов числовых данных.

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

''Недостатки'': есть необходимость в задании пороговых значений и количества кластеров.

Описание алгоритма :

[[file:Page1.png|thumb|center|1400px|Рисунок 1: Обзор CURE ]]

'''Шаг 1:''' Построение дерева кластеров, состоящего из каждой строки входного набора данных.

'''Шаг 2:''' Формирование «кучи» в оперативной памяти, расчет расстояния до ближайшего кластера (строки данных) для каждого кластера. При формировании кучи кластеры сортируются по возрастанию дистанции от кластера до ближайшего кластера. Расстояние между кластерами определяется по двум ближайшим элементам из соседних кластеров. Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

'''Шаг 3:''' Слияние ближних кластеров в один кластер. Новый кластер получает все точки входящих в него входных данных. Расчет расстояния до остальных кластеров для новообразованного кластера. Для расчета расстояния кластеры делятся на две группы: первая группа – кластеры, у которых ближайшими кластерами считаются кластеры, входящие в новообразованный кластер, остальные кластеры – вторая группа. И при этом для кластеров из первой группы, если расстояние до новообразованного кластера меньше чем до предыдущего ближайшего кластера, то ближайший кластер меняется на новообразованный кластер. В противном случае ищется новый ближайший кластер, но при этом не берутся кластеры, расстояния до которых больше, чем до новообразованного кластера. Для кластеров второй группы выполняется следующее: если расстояние до новообразованного кластера ближе, чем предыдущий ближайший кластер, то ближайший кластер меняется. В противном случае ничего не происходит.

'''Шаг 4:''' Переход на шаг 3, если не получено требуемое количество кластеров.

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

Прежде всего, алгоритм использует случайное разбиение выборки из <math> s </math> элементов на <math> p </math> частей, которые могут поместиться в память отдельной машины кластера. Затем во время первого прохода алгоритм уменьшает число кластеров в каждой подвыборке до <math> \frac{s}{pq} </math>, где <math> q \geq 1 </math> – некоторая константа (происходит объединение ближайших кластеров). Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

''Метрика Евклида:'' <math>\rho(p,k) = \sqrt{\sum_{i=1}^n (p_{i} - k_{i})^2}</math>

''«Манхеттенская» метрика:'' <math>\rho(p,k) =\sum_{i=1}^n |p_{i} - k_{i}|</math>

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

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

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

[[Файл:Param_c.png|400px|thumb|center| Рисунок 2: Результат работы алгоритка в зависимости от количесва представлений <math>c</math>.]]

Из рисунка видно, что при меньших значениях <math>c</math> качество работы алгоритма ухудшается

Выбранные точки сдвигаются на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Factor_a.png|400px|thumb|center| Рисунок 3: Чувствительность алгоритма к параметру <math>\alpha </math>.]]

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

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

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

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

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

Входные параметры: набор входных данных <math>S</math>, содержащий <math>m</math> точек в <math>n</math>-мерном пространстве
и требуемое количество кластеров <math>k</math>. Начиная с отдельных точек в виде отдельных кластеров, на каждом шаге ближайшая пара кластеров объединяются, чтобы сформировать новый кластер.Процесс повторяется до тех пор, пока не достигнет <math>k</math>.

'''procedure''' cluster(S,k)
'''begin'''
1. T:=build_kd_tree(S)
2. Q:-build_heap(S)
3. '''while''' size(Q)>k '''do''' {
4. u:=extract_min(Q)
5. v:= u.closest
6. delete(Q, V)
7. w := merge(u,v)
8. delete_rep(T, u); delete_rep(T, v); insert_rep(T, w)
9. w.closest := x /* x is an arbitrary cluster in Q */
10. '''for each''' x \in Q'''do''' {
11. '''if''' dist(w, x) < dist(w, w.closest)
12. w.closest := x
13. '''if''' x.closest is either u or w {
14. ''' if''' dist(x, x.closest) < dist(x, w)
15. x.closest := closest_cluster(T, x, dist(x, w))
16. '''else'''
17. x.closest := w
18. relocate(Q, x)
19. }
20. '''else if''' dist(x, x.closest) > d&(x, w) {
21. x.closest := w
22. relocate(Q, x)
23. }
24. }
25. insert(Q, w)
26. }
'''end'''

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

Являясь представителем иерархических алгоритмов кластеризации, имеет сложность <math> O(n^2 log(n)) </math> и <math> O(n^2) </math> для признаковых пространств малой размерности

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

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

[[Файл:Metod.png|400px|thumb|center| Рисунок 4: Дендрограмма агломеративных методов]]

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

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

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

'''Входные данные:''' набор данных <math> S </math> , количество кластеров <math>k</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>q</math>, <math>p</math> число разбиений выборки, <math>n</math> размерность.

Параметр <math>\alpha</math> для сжатия точек представления к центру кластера.

'''Выходные данные:''' требуемое количество <math> k </math> крастеров

===Оптимальный выбор параметров для алгоритма===

*размер случайной выборки <math> S </math> (''а'')

При запуске CURE со случайными размерами выборки в пределах от 500 до 5000 видно, что при размерах до 2000 были найдены кластеры низкого качества, начиная с 2500 точек и выше (2,5% от установленного размера данных), CURE всегда правильно определяет кластеры.

*число точек представителей <math> c </math> (''b'')
В оригинальной статье авторы показывают что уже при <math> c </math> равном <math>10</math> достигается неплохая эффективность.

*число разбиений выборки <math> p </math> ('''c''')
<math> p </math> должно быть выбрано таким, что <math> \frac{s}{pq} </math> > <math> k </math>

*размерность (''d'')
CURE хорошо себя чувствует при больших размерностях

*сжимающий фактор <math>\alpha</math>
В оригинальной статье авторы показывают что <math>\alpha</math> от 0.2 до 0.7 помогает хорошо выявлять несферические кластеры и подавлять редкие выбросы.

[[Файл:4pic.png|800px|thumb|center| Рисунок 5: Влияние параметров <math> S </math>, <math> c </math>, <math> p </math> и размерности на работу алгоритма.]]

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

* является масштабируемым алгоритмом

* неважна форма кластера и размер

*работает только на числовых данных

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

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

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

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

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

будет..

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

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

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

Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике [4]. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Theodoridis, Sergios; Koutroumbas, Konstantinos (2006). Pattern recognition. Academic Press. pp. 572–574. ISBN 978-0-12-369531-4.

[3] Guha, Sudipto; Rastogi, Rajeev; Shim, Kyuseok (2001). "CURE: An Efficient Clustering Algorithm for Large Databases" (PDF). Information Systems. 26 (1): 35–58. doi:10.1016/S0306-4379(01)00008-4

[4] Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP

Обсуждение участника:Лукьянова Анна

2016-11-29T14:23:22Z

Kronberg:

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: отсутствуют п.п. во 2 части--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 16:01, 25 октября 2016 (MSK)
* п.п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:00, 16 ноября 2016 (MSK)

== Замечания к статье "Алгоритм кластеризации с использованием представлений" ==

* п.1.1.1. Если взялись за классификацию алгоритмов, лучше разъяснить, что такое агломеративные, дивизивные, "четкие" и "нечеткие" алгоритмы. Было бы здорово даже сделать это в отдельной статье про задачу кластеризации, но это не обязательно [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.1.2. Метрики и некоторые подробности лучше перенести ниже, к "математическому описанию" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.2 выглядит дописанным не до конца. Там нужно разъяснить те неформальные конструкции, которые встречались ранее в п. 1.1.2. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.5. Псевдокод слишком псевдо, его следует сделать больше похожим на код, с соответствующим форматированием [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* следует добавить информацию об оптимальном выборе параметров алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* по-прежнему не хватает второй части...

Участник:JuliaA/Алгоритм кластеризации с использованием представлений

2016-11-29T14:21:53Z

Kronberg:

{{Assignment|Kronberg}}

Основные авторы описания: 
[[Участник:JuliaA|Ю.А. Антохина]], разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]] - [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]] 

[[Участник:Cookie|С.А. Шатков]], разделы [[#Математическое описание алгоритма|1.2]] - [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Масштабируемость алгоритма и его реализации|2.4]] 

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

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

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

Результат кластеризации зависит от того, как будут представлены кластеры. Например, средним всех точек кластера, или всеми точками кластера. Применение среднего возможно только в евклидовом пространстве. А использование всех точек неустойчиво к случайным выбросам. В CURE используется другой метод: для каждого кластера выбираются точки-представители. Выбирается постоянное число точек, которые будут представлять каждый кластер. Кластеры с наиболее похожими наборами репрезентативных точек объединяются на каждом шаге алгоритма.

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

Описание шагов

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

'''Шаг 2'''. Для каждого кластера выбираем <math>c</math> точек-представителей, максимально удаленных друг от друга. Чисто <math>c</math> остается постоянным.

'''Шаг 3'''. Объединяем кластеры с наиболее похожими наборами точек-представителей.
Если не достигнуто нужное число кластеров, то перейти на шаг 2.
Чтобы при объединении кластеров не выбирать каждый раз c точек-представителей из всех точек, мы выбираем их только из <math>2c</math> точек объединенных кластеров.

Выбранные точки сдвигаются на следующем шаге на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Exampleofalgorithmparametrs1.png|600px|thumb|center|Пример работы алгоритма для разных параметров <math>\alpha</math> [1].]]

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

Пусть дана матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек-представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>. Каждая строка матрицы представляет собой точку в <math>n</math> - мерном пространстве.

m число точек для кластеризации, n размерность.

Расстояние <math>\rho(a,b)</math> между точками <math>a = (a_{1},\dots,a_{n})</math> и <math>b = (b_{1},\dots,b_{n})</math> будем вычислять по формуле:

<math>\rho(a,b) = \sqrt{\sum_{i=1}^n (a_{i} - b_{i})^2}</math>

'''Шаг "Инициализация"'''

Выбираются <math>\lceil \gamma m\rceil</math> строк матрицы случайным образом. Например, можно использовать [https://ru.wikipedia.org/wiki/Reservoir_sampling Алгоритм R].

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

'''Шаг "Кластеризация"'''

В самом начале шага считаем каждую выбранную точку одноточечным кластером с центроидой в этой же точке.

Далее выполняем следующие шаги 1-2, пока количество кластеров не станет равно <math>h</math>:

Шаг 1:

Для каждого <math>i</math>-го кластера вычисляется центроида <math>\mu_{i}</math> по формуле:

<math>\mu_{i} = \frac{1}{s_{i}}\sum_{j\in S_{i}} x^{j}</math>, где <math>S_{i}</math> - номера строк матрицы <math>x</math>, входящие в <math>i</math>-й кластер; <math>s_{i}</math> - количество элементов в множестве <math>S_{i}</math>; <math>x^{j}</math> - <math>j</math>-я строка матрицы <math>x</math>.

Шаг 2:

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

'''Шаг "Назначение представителей"'''

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

Для этого используем следующий алгоритм:

Пусть <math>i</math> - текущее количество представителей, <math>S_{k}</math> - множество номеров строк матрицы <math>x</math>, входящие в <math>k</math>-й кластер, <math>R_{k}</math> - множество номеров строк матрицы <math>x</math>, назначенных представителями <math>k</math>-го кластера, а <math>x^{j}</math> - вектор-строка матрицы <math>x</math>, задающая точку в <math>n</math>-мерном пространстве.

<math>R_{k}</math> = [] % Пустое множество
a = Choose(<math>S_{k}</math>) % Выбор произвольного номера точки, входящей в кластер <math>k</math>
Add(<math>R_{k}</math>,a) % Добавление точки а во множество представителей
i = 1 % Текущее количество представителей кластера
While (i<c) do % Хотим найти с представителей для кластера
- rmax = 0
- For ( (y <math>\in</math> <math>S_{k}</math>) and (y <math>\notin</math> <math>P_{k}</math>) ) do % Поиск следующего представителя среди оставшихся точек кластера
- - rmin = <math>\rho(x^{a}</math>,<math>x^{y})</math>
- - For ( (j <math>\in</math> <math>R_{k}</math>) and (j <math>\neq</math> a) ) do % Поиск расстояния от точки с номером y до ближайшего представителя
- - - d = <math>\rho(x^{j}</math>,<math>x^{y})</math> % вычисление расстояния
- - - If (d < rmin) then
- - - - rmin = d
- - - endif
- - enddo
- - If (rmin > rmax) % Поиск точки, для которой расстояние до ближайшего представителя является максимальным
- - - rmax = rmin
- - - b = y % искомая точка
- - endif
- enddo
- Add(<math>R_{k}</math>,b) % Добавление новой точки в множество представителей
- i = i + 1 % текущее число представителей
enddo
</math>

'''Шаг "Сдвиг представителей к центроиде"'''

Для каждого представителя <math>x^{y}</math> из <math>k</math>-го кластера выполняется сдвиг к его центроиде <math>\mu_{k}</math> в <math>\alpha</math> раз:

<math>\hat{x}^{y} = \alpha\mu_{k} + (1-\alpha)x^{y}</math>.

Получаем множество <math>\hat{R}_{k}</math> из <math>c</math> точек, которые будут далее использоваться как представители этого кластера.

'''Шаг "Присваивание"'''

На данном шаге происходит присвоение неиспользованных точек (строк матрицы <math>x</math>) к кластерам. Для точки-строки <math>p</math> вычисляется расстояние до каждого представителя. Результат: строка <math>p</math> добавляется в поддерево кластера, которому принадлежит наиближайший представитель.

Результатом работы алгоритма является дерево, ветвями которого являются отдельные кластеры. Листьями кластеров являются строки из матрицы <math>x</math>.

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

Вычислительное ядро алгоритма представляет собой итерационное построение <math>k</math> кластеров с помощью иерархического метода, вычисление их центроид <math>\mu_{k}</math> и назначение точек-представителей. В ходе работы вычислительного ядра формируется дерево, в котором точки, выбранные на этапе '''Инициализации''' собраны в <math>h</math> поддеревьев. Точки-представители хранятся в отдельной структуре. Эти точки будут использованы для выбора кластеров для неиспользованных (на этапе '''Инициализации''') точек после работы вычислительного ядра.

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

Задача алгоритма кластеризации состоит в формировании <math>h</math> кластеров из <math>m</math> точек; число <math>h</math> задано заранее.

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

После этого происходит назначение точек-представителей для каждого кластера и их сдвиг к центроиде.

Далее для неиспользованных точек <math>x</math> происходит вычисление расстояний до всех точек-представителей. Точка помещается в тот кластер, точка-представитель которого находится ближе остальных.

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

[[Файл:SubCURE4.jpg|1100px|thumb|center|Схема работы алгоритма кластеризации CURE]]

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

Входные данные для кластеризации - это <math>n</math> репрезентативных точек в d мерном пространстве и необходимое число <math>h</math> кластеров. Для каждой точки необходимо вычислить расстояние до другой. Сложность этого этапа <math>O(n)</math>. Если искать ближайший кластер простым перебором, то сложность поиска будет <math>O(n)</math> для каждого кластера. Но для эффективного поиска сложность составляет <math>log_2{n}</math>. Эффективный метод описан в статье.<ref>Sudipto Guha (Stanford), Rajeev Rastogi (Bell Labs), Kyuseok Shim (Korea Institute of Technology). CURE: an efficient clustering algorithm for large databases. SIGMOD '98 Proceedings of the 1998 ACM SIGMOD international conference on Management of data, pp 73-84 </ref> Далее каждую точку необходимо вдвинуть к центроиде, сложность этой операции <math>O(2)</math>.
Таким образом худшее время выполнения алгоритма <math>O(n^2 log_2{n})</math>. Для двумерного пространства временная сложность может быть <math>O(n^2)</math>. Так что сложность алгоритма не хуже чем у центроидного. То есть при такой размерности входных данных CURE выполняется за полиномиальное время.<math>~^{[1]}</math>

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

'''Шаг "Инициализация"'''

В зависимости от алгоритма случайная выборка номеров строк матрицы <math>x</math> может производится либо зависимо, либо независимо друг от друга.

'''Шаг "Кластеризация"'''

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

'''Шаг "Назначение представителей"'''

[[Файл:Points c.png|800px|thumb|center|Последовательный информационный граф для точек-представителей]]

'''Шаг "Сдвиг представителей к центроиде"'''

Данный шаг выполняется независимо для каждой точки-представителя каждого кластера.

'''Шаг "Присваивание"'''

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

Основные шаги алгоритма информационно зависят от предыдущих шагов.

[[Файл:InfoCURE.jpg|1100px|thumb|center|Общий информационный граф алгоритма. В прямоугольниках - шаги алгоритма, в эллипсах - данные.]]

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

'''Шаг "Кластеризация"'''

Шаг 1 (вычисление центроид):

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

Шаг 2 (поиск "наилучших кластеров для объединения):

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

'''Шаг "Назначение представителей"'''

Представители внутри каждого кластера определяются независимо от других кластеров и поддаются распараллеливанию.

'''Шаг "Сдвиг представителей к центроиде"'''

Изменение положения представителей можно сделать независимо как от представителей данного кластера, так и представителей других кластеров. Это также хорошо поддаётся распараллеливанию.

'''Шаг "Присваивание"'''

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

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

Входные данные: матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>.

<math>m</math> число точек для кластеризации, <math>n</math> размерность.

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

Параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной выборке точек на шаге "Инициализация". Слишком малое значение <math>\gamma</math> может привести к объединению удалённых кластеров (если ни одна из точек предполагаемого кластера не была выбрана, они были присоединены к другому кластеру на этапе присваивания), а также к разделению кластеров на части (так как конечное количество кластеров фиксировано, а некоторые кластеры могут не набрать достаточное количество мест в выборке, чтобы их кластер сформировался). С другой стороны, скорость вычислений зависит от величины выборки: увеличение выборки при фиксированном числе кластеров <math>h</math> приведёт к дополнительным шагам на этапе кластеризации, а также к дополнительным вычислениям при нахождении кластеров, "наиболее подходящих" для объединения на каждом шаге. Кроме того, увеличение выборки приводит к уменьшению числа оставшихся точек, присвоение которых не входит в [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

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

Число точек представителей выбирается в зависимости от данных. Если возможно появление кластеров сложной формы, то точек должно быть больше, чтобы выявить их форму. В оригинальной статье авторы показывают что уже при <math>c</math> равном <math>10</math> достигается неплохая эффективность, в то время как при <math>c = 5</math> большой кластер был разделён на несколько частей.

[[Файл:Exampleofalgorithmparameters2.png|400px|thumb|center|Пример работы алгоритма для разных параметров <math>c</math>.]]

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

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

Состав выходного дерева:

- <math>m</math> листьев (векторов из <math>R^{1 \times n}</math>);

- вершины-кластеры представляют собой массивы указателей на листья (число таких указателей равно <math>m</math>);

- корень представляет собой массив указателей на вершины-кластеры (число таких указателей равно числу кластеров <math>h</math>);

- также имеется указатель на корень дерева.

'''Объём выходных данных:''' <math>m\times n + kp*(m + h + 1)</math>, где <math>kp</math> - коэффициент, равный отношению размера элемента из <math>R</math> к размеру указателя, зависящему от архитектуры платформы.

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

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

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

'''Недостатки''': есть необходимость в задании пороговых значений и количества кластеров, работает только на числовых данных, эффективен только для данных низкой размерности

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

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

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

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

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

Увы

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

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

== Существующие реализации алгоритма ==
Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике <ref>Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP</ref>. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

<references \>

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-29T14:20:56Z

Kronberg:

{{Assignment|IgorS|Kronberg}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Пусть <math>X=(x_{1},...,x_{n-1})^{T}</math> - исходный сигнал, который необходимо преобразовать умножением на тензор второго ранга <math>E_{pk}=e^{\frac{-2kpi\pi}{n}} </math>. Результатом данного преобразования (<math>E*X</math>) будет вектор <math>Y=(y_{1},...,y_{n-1})^{T}</math>, где <math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>. Данная формула является классической формулой ДПФ. Известно, что в общем случае умножение матрицы на вектор требует <math>O(n^{2})</math> арифметических операций, поэтому возникает вопрос о сокращении данного количества.

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

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

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

*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>. Все выкладки, приведенные выше, относятся ко второму этапу алгоритма Cooley – Tukey, который был использован в данной статье. Последующие шаги данного этапа делят подмножества полученные на предыдущем шаге вычисления БПФ.

В конечном итоге вышеупомянутый алгоритм сводится к двум этапам:

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 1'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 1 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье
Также необходимо заметить, что количеством рекурсий будет количество этапов выполнения БПФ, то есть глубина рекурсии будет равняться <math>log_{2}n</math>

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Вычисления проводились на суперкомпьютере «Ломоносов».

'''Основные технические характеристики суперкомпьютера "Ломоносов":'''
*Пиковая производительность: 1,7 Пфлопс
*Производительность на тесте Linpack: 901.9 Тфлопс
*Число вычислительных узлов х86: 5 104
*Число графических вычислительных узлов: 1 065
*Число вычислительных узлов PowerXCell: 30
*Число процессоров/ядер x86: 12 346 / 52 168
*Число графических ядер: 954 240
*Оперативная память: 92 ТБ
*Общий объем дисковой памяти вычислителя: 1,75 ПБ
*Основной тип процессора: Intel Xeon X5570/Intel Xeon 5670, Nvidia X2070
*Число типов вычислительных узлов: 8
*Основной тип вычислительных узлов: TB2-XN
*Все узлы связаны тремя независимыми сетями:
**Системная сеть - QDR InfiniBand, 40 Гбит/сек
**Сервисная сеть - Ethernet, 10 Гбит/сек, 1 Гбит/сек и 100 Мбит/сек
**Управляющая сеть - Ethernet, 10 Гбит/сек и 1 Гбит/сек
**Сеть барьерной синхронизации и сеть глобальных прерываний, Т-Платформы
При работе была использована библиотека FFTW последней версии (3.3.5). Скрипт mpicxx с компилятором Intel. Вычислительные узлы х86. Код исследуемой программы представлен в разделе [[#Существующие реализации алгоритма|Существующие реализации алгоритма]].
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров.
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

Участник:Victoria Stepanischeva/Быстрое преобразование Фурье (FFT)

2016-11-29T14:19:44Z

Kronberg:

{{Assignment|Kronberg}}
Авторы:

* [[Участник:Victoria_Stepanischeva|Степанищева В.С.]], группа 601 (Общее описание алгоритма, Вычислителное ядро алгоритма, Макроструктура алгоритма, Информационный граф, Ресурс параллелизма алгоритма)
* [[Участник:Igor_Munkin|Мунькин И.А.]], группа 601 (Математическое описание алгоритма, Схема реализации последовательного алгоритма, Последовательная сложность алгоритма, Входные и выходные данные алгоритма, Свойства алгоритма, Существующие реализации алгоритма)

{{algorithm
| name = Быстрое преобразования Фурье
| serial_complexity = <math>O(N \; log \, N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
| pf_height = <math>O(log \,N)</math>
| pf_width = <math>N</math>
}}

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

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

Алгоритм '''быстрого преобразования Фурье''', включая его рекурсивную
реализацию, был использован
[https://en.wikipedia.org/wiki/Carl_Friedrich_Gauss Карлом Фридрихом Гауссом]
еще в 1805 году для интерполяции траекторий астероидов, однако эта работа не
получила широкого признания. Алгоритм быстрого преобразования Фурье обрел свою
популярность благодаря работе
[https://en.wikipedia.org/wiki/James_Cooley James Cooley], работающего в то
время в [https://en.wikipedia.org/wiki/IBM IBM], и
[https://en.wikipedia.org/wiki/John_Tukey John Tukey], параллельно принимающего
участие в разработках [https://en.wikipedia.org/wiki/Bell_Labs Bell Labs] и
работающего в
[https://en.wikipedia.org/wiki/Princeton_University Принстонском университетe].
В их статье, изданной в 1965 году, они представили подробное описание алгоритма
и его программной реализации.

====Разновидности алгоритма быстрого преобразования Фурье====
Помимо традиционного и наиболее распространенного алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
существует также несколько других часто используемых реализаций алгоритма
быстрого преобразования Фурье.

=====PFA-алгоритм=====
Алгоритм [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm prime-factor]
(PFA), также называемый алгоритмом Good-Thomas, представляет собой алгоритм
быстрого преобразования Фурье, который представляет дискретное преобразование
Фурье размера <math>N = N_1 \cdot N_2</math> в виде двумерного
<math>N_1 \times N_2</math> дискретного преобразования Фурье, при условии, что
<math>N_1</math> и <math>N_2</math> - взаимно простые числа. Представленные
преобразования меньшего размера могут быть вычислены либо рекурсивным
применением PFA либо используя какой-либо иной метод быстрого преобразования
Фурье.

=====Алгоритм Bluestein=====
Алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein],
обычно называемый <math>\mathcal{Z}</math>-чирп алгоритмом, представляет собой
алгоритм быстрого преобразования Фурье, который вычисляет дискретное
преобразование Фурье различных размеров с помощью представления оного в виде
линейной свертки. Другой алгоритм быстрого преобразования Фурье, использующий
свойства простых чисел, алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Rader], также вычисляет
дискретное преобразование Фурье в виде свертки.

====Приложения быстрого преобразования Фурье====

Алгоритм быстрого преобразования Фурье имеет множество областей приложения,
таких как:
* Обработка изображений
* Цифровое сжатие
* Численное интегрирование
* Быстрые методы решения уравнения Пуассона
* Спектральные методы решения обыкновенных дифференциальных уравнений

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

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

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

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

=====Цифровое сжатие=====
Одним из первых форматов файла-контейнера для хранения записи оцифрованного
аудипотока является формат WAV. Этот формат чаще всего используется в качестве
оболочки для несжатого звука. При таком кодировании в WAV-файле хранится полная
информация об исходном звуке, оцифрованном и проквантованном с некоторой
частотой, например 44 кГц. Этой информации абсолютно достаточно для
воспроизведения всех частот исходного сигнала, меньших половины частоты
квантования (по [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%9A%D0%BE%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%D0%B0 теореме Котельникова] ). При этом одна
минута записи занимает около 15 Мб, поэтому в настоящее время очень популярным
стал формат кодирования MPEG Layer-3 со сжатием.

При сжатии кодеком MPEG Layer-3 исходный звуковой сигнал разбивается на
фрагменты, длительностью по 50 миллисекунд, каждый из которых анализируется
отдельно. При анализе фрагмент раскладывается на гармоники по методу Фурье, из
которых в соответствии с теорией восприятия звука человеческим ухом
выбрасываются те гармоники, которые человек хуже воспринимает на фоне остальных:
* более тихие гармоники на фоне более громких
* звуки, замаскированные вследствие инертности слуха (так, например, если за очень громким хлопком, с задержкой в долю секунды, пойдет какой-то иной кратковременный сигнал, то его слышно не будет)

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

''Битрейт'' - это объем информации на каждую секунду записи:
* чем он меньше, тем меньший размер имеют файлы с одинаковой по времени длине
* чем он меньше, тем большее количество "лишних" гармоник приходится удалять

===Математическое описание алгоритма===
Пусть задан вектор действительных чисел
<math>\left(f_1, f_2, f_3, \dots, f_{N-1} \right)</math>

Дискретное преобразование Фурье определено следующим образом

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, e^{\left(\frac{i2\pi kn}{N}\right)}
</math>

Обозначим <math>W_N = e^{\left(\frac{i2\pi}{N}\right)}</math> - <math>N</math>-ый
корень единицы. Таким образом <math>(W_N)^N = 1</math>. Несложные математические
преобразования приводят формулу дискретного преобразования Фурье к следующему
виду

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_n^{-nk}
</math>

Таким образом, алгоритм вычисления дискретного преобразования Фурье состоит из
2 шагов:
# Вычисление поворотных коэффициентов <math>W_n^{-nk},\; n,k = 0, 1, \dots, N-1</math>
# Вычисление коэффициентов Фурье <math>F_k,\; k = 0, 1, \dots, N-1</math>

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

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_{N}^{-nk}
= \sum_{n = 0}^{N/2 - 1}\, g_n\, W_{N/2}^{-nk}
+ \sum_{n = 0}^{N/2 - 1}\, h_n\, W_{N/2}^{-nk}
</math>

Следовательно, четные и нечетные коэффициенты Фурье могут быть записаны в
следующем виде:

<math>
F_{2k} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left(f_n + f_{n + N/2}\right)
}_{g_n} \, W_{N/2}^{-nk}
</math>

<math>
F_{2k+1} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left((f_n + f_{n + N/2}) W^{-n}\right)
}_{h_n} \, W_{N/2}^{-nk}
</math>

Таким образом, вычисление дискретного преобразования Фурье от <math>N</math>
коэффициентов сводится к вычислению 2 дискретных преобразований Фурье от
<math>N/2</math> коэффициентов. Применяя данную идею рекурсивно, получаем
алгоритм быстрого преобразования Фурье.

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

[[File:Stepmoon_buttefly.png|left|200px]]
В случае размера входных данных равному <math>N = 2^M</math> вычислительным
ядром алгоритма являются так называемые "бабочки". В элементарном случае
"бабочка" является двухточечным преобразованием.

<math>
g_n = f_n + f_{n + N/2}
</math>

<math>
h_n = \left(f_n - f_{n + N/2}\right)\, W^{-n}
</math>

===Макроструктура алгоритма===
Описываемый алгоритм работает по принципу
[https://en.wikipedia.org/wiki/Divide_and_conquer_algorithms "разделяй и властвуй"].

Рассмотрим общую структуру для входных данных размера <math>N = N1 \cdot N2</math>
# Исходное множество точек разбивается на <math>N2</math> равных подмножеств размером <math>N1</math>.
# Над каждым из полученных множеств выполняется быстрое преобразование Фурье. Для его вычисления над каждым из подмножеств рассматриваемого множества снова выполняется деление на равные части. Такое разбиение продолжается до тех пор, пока количество элементов, над которыми необходимо выполнить быстрое преобразование Фурье, не будет равно одному.
# После этого выполняется объединение всех промежуточных результатов. Полученные на предыдущем шаге множества объединяются за линейное время.

Ниже представлена схема алгоритма Cooley-Tukey для <math>N = 2^M</math>

[[File:Stepmoon_macro.png|center|800px]]

===Схема реализации последовательного алгоритма===
Ниже представлен прототип реализации для <math>N = 2^M</math>.
<source lang=perl>
use Math::Complex;

sub fft {
my $input = shift;
return $input if @{ $input } == 1;
my @w = map {
my $theta = 2 * pi * $_ / @{ $input };
Math::Complex->make(cos($theta), sin($theta));
} (0 .. $#input);
my $odd = fft([ map { $input->[2 * $_ + 1] }, (0 .. @{ $input } / 2 - 1) ]);
my $even = fft([ map { $input->[2 * $_] }, (0 .. @{ $input } / 2 - 1) ]);
return [ map {
$even->[$_ % @{ $even }] + $w[$_] * $odd->[$_ % @{ $odd }];
} (0 .. $#input) ];
};
</source>

===Последовательная сложность алгоритма===
Если считать только главные члены выражений для последовательной сложности алгоритма, то простой алгоритм Cooley-Tukey может быть выполнен за <math>N\, log\, N</math> операций. Таким образом, простой алгоритм Cooley-Tukey относится к линейно-логарифмическому классу по последовательной сложности.

===Информационный граф===
Ниже представлен информационный граф для простого алгоритма Cooley-Tukey для <math>N = 8</math>, <math>\;h</math> - операция сложения двух комплексных чисел, <math>g</math> - операция вычитания двух комплексных чисел и умножения результата вычитания на комплексное число (поворотный множитель). В последнем столбце операций умножения не производится.

[[File:Stepmoon_Info_graph.png|center|500px]]

===Ресурс параллелизма алгоритма===
Простой алгоритм Cooley-Tukey имеет критический путь, состоящий из
<math>log\, N</math> операций сложения и вычитания и <math>log\, N</math>
операций комплексного умножения (основание логарифма зависит от выбранного на
каждом шаге алгоритма разбиения). Следовательно, простой алгоритм быстрого
преобразования Фурье в общем случае может быть отнесен к логарифмическому классу
по параллельной сложности.

===Входные и выходные данные алгоритма===
'''Входные данные:''' измеренные значения сигнала в дискретных временных точках с номерами <math>0 \dots N</math>: <math>f \in \mathbb{R}^N</math>.

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

'''Выходные данные:''' вектор компонент спектра исходного сигнала: <math>F \in \mathbb{C}^N</math>.

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

===Свойства алгоритма===
Обработку подмножеств, получаемых после разбиения, можно выполнять независимо,
этот факт можно использовать при распараллеливании алгоритма.
В случае рекурсивной реализации глубина рекурсии составит <math>log\, N</math>.
Соотношение последовательной и параллельной сложности в случае неограниченных
ресурсов является линейным.
Вычислительная мощность алгоритма, как отношение числа операций к
суммарному объему входных и выходных данных, является логарифмической.

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

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

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

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

===Масштабируемость алгоритма и его реализации===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:
* число процессоров [ 5 : 45 ] с шагом 5
* размер вектора [ 256 : 16384 ] с шагом равным степени двойки

Условия экспериментов:
* Для тестирования была использована библиотека FFTW версии 3.3.5. Библиотека была сконфигурирована и собрана локально
<source>
./configure --enable-mpi --prefix=/mnt/data/users/dm4/vol12/munkinigor_1854/fftw_mpi_build_instalation
make install
</source>

* Исходный код был скомпилирован с помощью компилятора mpicc из модуля openmpi/1.8.4-gcc
<source>
module add openmpi/1.8.4-gcc
mpicc test.c -Ifftw_mpi_build_instalation/include/ -Lfftw_mpi_build_instalation/lib/ -lm -lfftw3_mpi -lfftw3 -o ../_scratch/bench
</source>

На следующем рисунке приведен график производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.
[[File:Stepmoon_performance.png|center|800px]]

[https://github.com/FFTW/fftw3 Текст исследуемой программы]

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

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

===Существующие реализации алгоритма===
Наиболее популярной библиотекой, содержащей реализацию быстрого преобразования
Фурье, является [http://fftw.org/ FFTW], изначально разработанная сотрудниками
[https://en.wikipedia.org/wiki/Massachusetts_Institute_of_Technology MIT]
Matteo Frigo и Steven G. Johnson. На сегодняшний день исходный код библиотеки
распространяется под свободной лицензией
[https://en.wikipedia.org/wiki/GNU_General_Public_License#Version_2 GNU General Public Licence v2]
с помощью сервиса [https://github.com/FFTW/fftw3 Github], тем самым давая
возможность сообществу принимать участие в разработке. Несмотря на то, что сама
библиотека [http://fftw.org/faq/section2.html#whynotfortran написана на языке C]
существуют интерфейсы для работы с ней используя такие языки программирования
как Fortran, C++ и другиe.

Для разбиения преобразований, размеры которых являются составным числом, на
меньшие используется одна из многочисленных реализаций алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
(в зависимости от разложения на простые множители и паттернов доступа к памяти).
В свою очередь для преобразований, размеры которых являются простыми числом
используется либо алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Raider], либо алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein].
Библиотека признана самой быстрой реализацией быстрого преобразования Фурье,
гарантируя на любых объемах входных данных сложность
<math>O \left(n\; log\, n \right)</math>. Существует реализация FFTW и с
поддержкой [https://en.wikipedia.org/wiki/Message_Passing_Interface MPI],
позволяющая работать с данными не помещающимися в память. Однако перегруппировка
данных приводит к оверхеду, которого трудно избежать при in-place вычислении
преобразований различных размеров.

==Литература==
[1] L. Rabiner, B. Gold, ''"Theory and application of digital signal processing"'' // Prentice Hall, New Jersey, 1975.

[2] Бахвалов Н.С., Жидков Н.П., Кобельков Г.М. ''"Численные методы"'' // БИНОМ. Лаборатория знаний, Москва, 2008.

[3] M. Frigo, S. G. Johnson ''"FFTW Documentation"'' // [http://fftw.org/fftw3_doc/ fftw.org]

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-29T14:16:43Z

Kronberg:

{{Assignment|Kronberg}}

{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
В общем случае многомерное преобразование Фурье соответствует умножению на матрицу преобразования по каждой из координат, что для массива данных <math>N_1\times N_2 \times \cdots \times N_m</math> означает выполнение <math>\sum_{i=1}^m \prod_{k\neq i} N_k</math> одномерных преобразований. Ключевым наблюдением, приводящим к быстрому алгоримту для вычисления преобразования, является возможность свести (с некоторыми оговорками) одномерное преобразование к двумерному, которое для <math>N = mn</math> требует <math>m + n</math> рекурсивных вызовов, что, при применении такого метода на всех уровнях рекурсии, даёт общую сложность алгоритма <math>O(N \log N)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math> (т.е. <math>\epsilon_N</math> является корнем из 1 степени <math>N</math>, но не является корнем никакой меньшей степени). Число <math>N</math> при этом называется порядком преобразования.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

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

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math> (уровней рекурсии при этом будет <math>K \sim \log N</math>). В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

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

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

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

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

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

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

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

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

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

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

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

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

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

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

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

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

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

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

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

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

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

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

=== Масштабируемость алгоритма и его реализации ===
Хотя, как уже было указано, алгоритм поддаётся реализации с относительно небольшим числом пересылок, следует отметить, что вычислительна нагрузка на отдельные вычислительные ядра невелика и сопоставима с объёмом пересылок. При этом сами пересылки достаточно объёмны (весь рабочий вектор), нелокальны (все-со-всеми), и не могут проводиться одновременно с вычислениями. По этим причинам, ожидать от алгоритма хорошей масштабируемости не приходится, несмотря на «хорошие» свойства информационного графа. Это и подтверждается экспериментом:

[[Файл:TIFFTEfficiency.png|center|thumb|800px|Рисунок 3. Эффективность распараллеливания быстрого преобразования Фурье, выраженная как отношение времени работы на одном процессоре к произведению времени работы на <math>n</math> процессорах на <math>n</math>. <math>N</math> — порядок преобразования.]]

При этом, однако, умеренного ускорения всё же удаётся добиться:
[[Файл:TIFFTSpeedup.png|center|thumb|800px|Рисунок 4. Ускорение, получаемое при распараллеливании преобразования Фурье. Обозначения те же, что и на рис. 3]]

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

При измерениях использовалась реализация алгоритма, имеющаяся в библиотеке Intel® MKL, расчёты проводились на суперкомпьютере «Ломоносов». Код доступен [https://bitbucket.org/timokhin_ivan/fft/src здесь].

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

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

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

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

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-29T14:09:45Z

Kronberg:

{{Assignment|IgorS|Kronberg}}

{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора — принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип «разделяй и властвуй», глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители, не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицей) до составного числа. В процессе слияния добавленные значения отбрасываются.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование проводилось на вычислительном комплексе IBM Blue Gene/P

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

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

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

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

2016-11-28T08:43:24Z

Kronberg:

== Замечания к [[Участник:Ruslanlazovskiy/CHAMELEON]] ==

1) все ссылки в статье не работают

2) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

3) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

== Мои правки ==

2) и 3) теперь сделаны как надо. В 1) не удалось поправить самую первую ссылку, ресурс с последовательной реализацией действительно умер.

== Замечания к статье про Хамелеон (ещё порция) ==

* Ссылки на авторов и список литературы - присоединяюсь к замечаниям. Список литературы действительно всего из одного наименования? [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* В разделе 1 пояснить, нужно ли заранее знать число кластеров. Это неясно и из описания входных и выходных данных, должно же оно быть хоть где-нибудь [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.2. Когда вводим граф, желательно пояснить аргументы V и E в скобках. Аналогично с параметром m, который встречается впервые [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.6. Стоит сделать логарифм красивей [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

== Правки - порция 2. ==

* В список литературы добавлена статья с исследованием параллелизма. Остальные найденные статьи по Chameleon представляют собой кальку с оригинальной статьи ( первый пункт в списке ) в разделе описания алгоритма + описание задачи, для которой применялся алгоритм, для примера добавил одну из таких статей.
* Сделано
* Сделано
* Поправил, добавил описание "предельного" случая.

* Изменил статью в соответствии с замечаниями к 2.4

== Замечания к пункту 2.4 ==

* Отсутствуют подписи к меткам на оси числа процессов
* Желательно сделать крупнее размер шрифта подписей

== Ещё замечание ==

* Все, кажется, хорошо, но плохо оформлены скобки в тексте, их надо писать без пробела (так), а не с пробелом по краям ( так не надо ). Я начал исправлять, но их слишком много, поправьте пожалуйста. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 11:43, 28 ноября 2016 (MSK)

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

2016-11-28T08:43:06Z

Kronberg:

== Замечания к [[Участник:Ruslanlazovskiy/CHAMELEON]] ==

1) все ссылки в статье не работают

2) список литературы оформлен неправильно - см. как сделано в [[Разложение_Холецкого_(метод_квадратного_корня)]]

3) для оформления (псевдо) кода следует использовать тег <nowiki><source lang="..."></nowiki>

== Мои правки ==

2) и 3) теперь сделаны как надо. В 1) не удалось поправить самую первую ссылку, ресурс с последовательной реализацией действительно умер.

== Замечания к статье про Хамелеон (ещё порция) ==

* Ссылки на авторов и список литературы - присоединяюсь к замечаниям. Список литературы действительно всего из одного наименования? [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* В разделе 1 пояснить, нужно ли заранее знать число кластеров. Это неясно и из описания входных и выходных данных, должно же оно быть хоть где-нибудь [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.2. Когда вводим граф, желательно пояснить аргументы V и E в скобках. Аналогично с параметром m, который встречается впервые [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

* Раздел 1.6. Стоит сделать логарифм красивей [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:09, 14 ноября 2016 (MSK)

== Правки - порция 2. ==

* В список литературы добавлена статья с исследованием параллелизма. Остальные найденные статьи по Chameleon представляют собой кальку с оригинальной статьи ( первый пункт в списке ) в разделе описания алгоритма + описание задачи, для которой применялся алгоритм, для примера добавил одну из таких статей.
* Сделано
* Сделано
* Поправил, добавил описание "предельного" случая.

* Изменил статью в соответствии с замечаниями к 2.4

== Замечания к пункту 2.4 ==

* Отсутствуют подписи к меткам на оси числа процессов
* Желательно сделать крупнее размер шрифта подписей

== Ещё замечание

* Все, кажется, хорошо, но плохо оформлены скобки в тексте, их надо писать без пробела (так), а не с пробелом по краям ( так не надо ). Я начал исправлять, но их слишком много, поправьте пожалуйста. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 11:43, 28 ноября 2016 (MSK)

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-28T08:37:35Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|Algoman}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy|Лазовский Р. А.] ( разделы 1.1 - 1.4 , 1.7 , 1.8 ),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87|Мустафаев Э. Э.] ( разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2 )

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики (простейший пример — евклидова метрика). Не следует путать задачу кластеризации с задачей классификации: в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик (возможные метрики будут подробно описаны далее). Число получаемых в итоге кластеров в явном виде не задаётся.

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

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math> ( возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа ( т.е. объекты ), а <math>E</math> - множество ребер графа ( т.е. построенные связи между ближайшими соседями ). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> ( имеется ввиду количество вершин ) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> ( имеется ввиду количество вершин ). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

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

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

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

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

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

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

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

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

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

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений ( для вычисления квадратичной нормы разности векторов).

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

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON ( см. раздел "Существующие реализации" ). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

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

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

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

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

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

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

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

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

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

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

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

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью, включающий в себя значительную модификацию исходного алгоритма, но не приводится рабочая реализация.

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

Для исследования такой масштабируемости вширь использовалась референсная последовательная реализация алгоритма ( м. раздел "Существующие реализации" ). Соответствующая программа запускалась на системе BG/P на одном вычислительном узле. Характеристики вычислительного узла, а также микропроцессорного ядра - элемента такого узла, приводятся в <ref>http://hpc.cmc.msu.ru/bgp</ref> Таким образом, удостоверенными экспериментальными данными являются только значения, полученные для случая 1 процесса. Значения для случаев 2 и 4 процессов являются ОЦЕНОЧНЫМИ и выводятся из результатов работы модифицированной версии алгоритма, исследуемой в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. К сожалению, указанной реализации авторы не предоставляют.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Теоретически возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

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

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Участник:Ruslanlazovskiy/CHAMELEON

2016-11-28T08:36:34Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|Algoman}}

{{algorithm
| name = CHAMELEON
| serial_complexity = <math>O(n*m + n*log{n} + m*log{m})</math>
| pf_height = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| pf_width = <math>O(n)</math> - этап 1. <math>O(q)</math> - отдельная итерация этапа 3.
| input_data = <math>n^2 / 2</math>
| output_data = <math>n</math>
}}

Авторы статьи:
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Ruslanlazovskiy|Лазовский Р. А.] ( разделы 1.1 - 1.4 , 1.7 , 1.8 ),
[https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%9C%D1%83%D1%81%D1%82%D0%B0%D1%84%D0%B0%D0%B5%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B2%D0%B8%D0%BD_%D0%AD%D0%BB%D1%8C%D0%BC%D0%B0%D0%BD%D0%BE%D0%B2%D0%B8%D1%87|Мустафаев Э. Э.] ( разделы 1.5 , 1.6 , 1.9 , 1.10 , 2.2 )

==Свойства и структура алгоритма==
===Общее описание алгоритма===
CHAMELEON – алгоритм динамической иерархической кластеризации графа, то есть процесса разбиения графа на несколько подграфов-кластеров таким образом, что данные внутри одного кластера имеют максимально схожи, а данные в разных кластерах — максимально различны. В классических алгоритмах кластеризации схожесть объектов определяется с помощью некоторой метрики (простейший пример - евклидова метрика). Не следует путать задачу кластеризации с задачей классификации - в последней характеристики объекта, необходимые для попадания в тот или иной класс, известны заранее, в рассматриваемой же задаче они становятся известны в процессе решения. Первоначально алгоритм был описан в статье<ref>CHAMELEON: A Hierarchical Clustering Algorithm Using Dynamic Modeling. George Karypis, Eui-Hong Han, Vipin Kumar. IEEE Computer 32(8): 68-75, 1999</ref>.

Алгоритм CHAMELEON работает в 3 этапа. На первом этапе исходное множество объектов организуется в граф по принципу k ближайших соседей. На втором этапе этого граф разбивается на достаточно малые подграфы-кластеры. На третьем этапе происходит агломеративная иерархическая кластеризация полученных подграфов в соответствии с одной из выбранных метрик ( возможные метрики будут подробно описаны далее ). Число получаемых в итоге кластеров в явном виде не задаётся.

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

Исходные данные: Первоначально исходными данными алгоритма являются <math>n</math> векторов длины <math>p</math>, каждый из которых соответствует одному объекту. На основании значений элементов этих векторов строится матрица смежности размера <math>n * n</math> ( возможно сокращение требуемого объема памяти до <math>(n*(n - 1))/ 2</math> в соответствии с выбранной метрикой. К исходным данным также относится набор параметров. Это <math>k</math> - количество ближайших соседей на первом этапе алгоритма, <math>q</math> - отношение количества вершин в наибольшем подграфе по отношению к общему числу объектов на втором этапе алгоритма, а также параметры <math>T_{RI}, T_{RI}</math> - пороговые значения, после которых прекращается агломеративная кластеризация на третьем этапе. Следует особо отметить, что число получаемых в итоге кластеров заранее не известно, хотя на него и можно повлиять изменением значений перечисленных параметров.

Первый этап алгоритма: На первом этапе на основании матрицы смежности строится граф <math>G = (V, E)</math> <math>k</math> ближайших соседей, где <math>V</math> - множество вершин графа ( т.е. объекты ), а <math>E</math> - множество ребер графа ( т.е. построенные связи между ближайшими соседями ). Указанный граф не обязательно является связным.

Второй этап алгоритма: Граф <math>G = (V, E)</math> итеративно разбивается на множество подграфов <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math>, где <math> \cup V_{i} = V, i = 1 .. m</math>. Параметр <math>m</math> явно не задаётся, выполнение этого этапа алгоритма прекращается по выполнении описанных далее условий. На каждой итерации выбирается <math>G_{b}</math> с числом вершин, наибольшим среди всех подграфов, имеющихся на данной итерации. Этот граф разбивается на 2 подграфа <math>G_{bi}</math> и <math>G_{bj}</math> таких, что 1) <math>min(V_{bi},V_{bj}) >= 0.25 * V_{b}</math> ( имеется ввиду количество вершин ) и 2) <math>\sum{E_{kl}}, E_{kl} = (v_{k}, v_{l}), v_{k} \in V_{bi} , v_{l} \in V_{bj} </math> минимальна среди всех разбиений, удовлетворяющих 1). Итеративный процесс прекращается, когда <math>\sum{v_{b}} <= q * \sum{v} , v_{b} \in V_{b} , e \in E</math> ( имеется ввиду количество вершин ). Здесь <math>q</math> - задаваемый параметр, на практике он варьируется от <math>0.01</math> до <math>0.05</math>. Полученные подграфы называются малыми кластерами.

Третий этап алгоритма: Множество кластеров <math>G_{i} = (V_{i}, E_{i}), i = 1 .. m</math> итеративно преобразуется в множество кластеров <math>G_{j} = (V_{j}, E_{j}), j = 1 .. l</math>, <math>l <= m</math>. Для этого вводятся следующие понятия:

<math>EC_{(C_{i},C_{j})}</math> - абсолютная взаимная связность пары кластеров <math>C_{i}, C{j}</math>. Это суть сумма весов ребер, соединяющих вершины, принадлежащие <math>C{i}</math> c вершинами из <math>C{j}</math>. <math>EC_{(C_{i},C_{i})}</math> вычисляется как сумма ребер, входящих в разделитель, разбивающий <math>C{i}</math> на два равных подграфа. 
<math>S_{EC_{(C_{i},C_{j})}}</math> - абсолютное взаимное сходство пары кластеров <math>C_{i}, C{j}</math>. Это суть среднее сходство между соединенными вершинами, принадлежащими <math>C{i}</math> и <math>C{j}</math> соответственно. Соединения обусловлены разбиением общего графа, полученного на первом этапе алгоритма. 
<math>RI_{(C_{i},C_{j})} = \frac{2*|EC_{(C_{i},C_{j})}|}{|EC_{C_{i}}|+|EC_{C_{j}}|}</math> - относительная взаимная связность пары кластеров <math>C_{i}, C{j}</math> 
<math> RC_{(C_{i},C_{j})}= \frac{S_{EC_{(C_{i},C_{j})}}}{\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{i})}}+\frac{|C_{i}|}{|C_{i}+C_{j}|}*S_{EC_{(C_{j})}}}</math> - относительное взаимное сходство пары кластеров <math>C_{i}, C{j}</math> 

На основании этих показателей осуществляется агломеративная иерерхическая кластеризация. Существует две стратегии анализа показателей сходства. В первом случае для каждой пары кластеров <math>C{i}, C{j}</math> проверяется истинность выражений <math>RI_{(C_{i},C_{j})} >= T_{RI}</math> и <math>RC_{(C_{i},C_{j})} >= T_{RC}</math>, где <math>T_{RI}, T_{RI}</math> - заранее заданные пороговые значения. Если для некоторого <math>C_{i}</math> таких <math>C_{j}</math> несколько, то конкретная пара определяется по максимуму значения <math>EC_{(C_{i},C_{j})}</math>. Во втором случае выбираются пары кластеров, максимизирующие функцию вида <math>RI_{(C_{i},C_{j})}*RC_{(C_{i},C_{j})}^\alpha</math>. Здесь <math>\alpha</math> - заданный пользователем параметр. В обоих случаях процесс останавливается либо когда на очередной итерации не находится подходящих пар кластеров, либо когда остаётся только один кластер.

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

===Вычислительное ядро алгоритма===
В алгоритме 3 основных вычислительных ядра, по одному на каждый этап алгоритма.

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

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

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

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

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

Схема представлена в виде C++-подобного псевдокода, макрооперации в алгоритме выделены в соответствии с предыдущим разделом описания.

<source lang="C++">
// First stage.
int k // Number of neighbors.
float v[n][p] // Initial vectors.
float M[n][n] // Adjacency matrix.
for (int i = 0; i < n; ++i) {
for (int l = 0; l < n; ++l) {
M[i][l] = Compute_metric(v[i],v[l]);
}
}
Graph max_graph // Structure/class that represents a graph.
Neighbor_list list // Here neighbors are initially stored.
max_graph.add_vertices // Vertices ~ initial vectors.
for (int i = 0; i < n; ++i) {
for (int l = i + 1; i < n; ++i) { // "Smart" version - we do not repeat same vertex combinations.
if (neighbor_number < k) {
add_neighbor(v[i],v[l]) // Just add.
}else{
substitute_neighbor(v[i],v[l]) // Check whether a new element is closer than some of the oldies.
}
}
max_graph.add_neighbors // Looks at neighbor lists of current vector and adds them
}
</source>

<source lang="C++">
// Second stage.
float percent // Determines when to stop splitting graphs.
Graph graphs[n] // GRAPHS WILL MOST LIKELY TAKE LESS SPACE, IT'S JUST THE UPPER LIMIT.
max_graph = find_max_graph() // Biggest graph by number of vertices available.
while (graph_size(max_graph) > n * percent) {
Split_graph(max_graph); // Split the graph - a macro operation that represents the second phase.
}
</source>

<source lang="C++">
// Third stage.
Graph graphs[m] // That's how many graphs we got. m <= n.
bool pairs_exist // Check if the're pairs of clusters to unite.
while (num_graphs > 1 && pairs_exist){
pairs_exist = false // So we don't repeat if it fails.
for (int i = 0; i < m; ++i) {
for (int l = i + 1; l < m; ++l) { // Also a "Smart" version.
check_pair(pairs_exist, graphs[i], graphs[l]); // Check whether graphs are similar enough by some metrics.
if (pairs_exist) { Unite_graphs(graphs[i], graphs[l]) }; // Pairs_exist is set to true if something's found.
}
}
}
</source>

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

Общая временная сложность последовательного варианта алгоритма CHAMELEON определяется как <math>O(nm + nlog{n} + mlog{m})</math>, где <math>n</math> - число исходных объектов, <math>m</math> - число малых кластеров, полученных после первого этапа работы. В случае "предельного" разбиения <math>m = n</math> эта оценка превращается в <math>O(n^2)</math>. В любом случае эта оценка не учитывает необходимости построения матрицы смежности по исходному набору векторов (авторы оригинальной статьи в своих исследованиях подразумевают, что матрица смежности уже построена), что означает дополнительные <math>O(n^2)</math> операций. Тогда оценка будет составлять <math>O(n^2 + nm + nlog{n} + mlog{m})</math> операций или <math>O(n^2)</math> в случае "предельного" разбиения.
Следует также обратить внимание, что это оценка по числу не сложений и умножений, а достаточно крупных операций. Например, вычисление метрики между двумя векторами рассматривается как одна операция, а она включает в себя <math>n</math> умножений и <math>2n</math> сложений ( для вычисления квадратичной нормы разности векторов).

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

Информационный граф дан в соответствии с макроструктурой алгоритма. Следует отметить, что имеются успешные попытки распараллелить 2 и 3 этапы алгоритма CHAMELEON ( см. раздел "Существующие реализации" ). Однако они включают в себя модификацию исходного алгоритма. Также возможно распараллеливание выборки пар кластеров и подсчёта их метрик внутри каждой из вершин stage_3_iter. Структура информационного графа внутри этих итераций аналогична структуре информационного графа первого этапа алгоритма.

[[File:CHAMELEON ruslanlazovskiy.png]]

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

Параллельную сложность алгоритма CHAMELEON следует оценивать отдельно для каждого этапа.
На первом этапе алгоритм поиска <math>k</math> ближайших соседей может быть выполнен за <math>n - 1</math> вычислений значения метрики между двумя векторами.
На втором этапе итерации алгоритма выполняются строго последовательно, а распараллеливание алгоритма внутри итерации не относится к теме статьи.
На третьем этапе итерации также выполняются последовательно, однако возможно распараллеливание обработки пар кластеров внутри итерации. Каждая итерация может быть выполнена за <math>q - 1</math> вычислений значения метрики между двумя кластерами, где q - количество кластеров на этой итерации.

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

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

<math>O</math> - набор из <math>n</math> векторов длины <math>p</math>. 
<math>k</math> - число, определяющиее количество ближайших соседей, по которым строится первоначальный граф. 

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

<math>B</math> - вектор длины <math>n</math>, значение <math>i</math>-го элемента указывает на принадлежность соответствующего вектора одному из кластеров.

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

Соотношение последовательной и параллельной сложности: Различные этапы алгоритма строго последовательны относительно друг друга. На первом этапе отношение последовательной сложности алгоритма к параллельной есть <math>n/2</math>. На втором и третьем этапах различные итерации последовательны относительно друг друга. Однако внутри итераций допускается некоторый параллелизм. Например, для итераций третьего этапа в наилучшем случае отношение сложности последовательной реализации к параллельной есть <math>q/2</math>, где <math>q</math> - число кластеров на конкретной итерации.

Вычислительная мощность: графовые алгоритмы, вообще говоря, обладают низкой вычислительной мощностью. В случае CHAMELEON вычислительная мощность первого этапа равна <math>O(1)</math>. Для второго и третьего этапов оценка вычислительной мощности по сложениям и умножениям затруднительна, однако в терминах макроопераций можно дать грубую оценку. Вычислительная мощность каждой итерации второго этапа - <math>1 / \sum C_n^k</math>, где <math>n</math> - число вершин в выбранном подграфе, а <math>k</math> варьируется от <math>0.25 * n</math> до <math>0.5 * n</math>. Вычислительная мощность каждой итерации третьего этапа в этих терминах - <math>O(1)</math>.

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

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

Как можно увидеть из раздела "существующие реализации", параллельной реализации алгоритма CHAMELEON на система с распределенной памятью найдено не было. Однако в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. приводится экспериментальный вариант параллельной реализации посредством OpenMP для систем с общей памятью, включающий в себя значительную модификацию исходного алгоритма, но не приводится рабочая реализация.

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

Для исследования такой масштабируемости вширь использовалась референсная последовательная реализация алгоритма ( м. раздел "Существующие реализации" ). Соответствующая программа запускалась на системе BG/P на одном вычислительном узле. Характеристики вычислительного узла, а также микропроцессорного ядра - элемента такого узла, приводятся в <ref>http://hpc.cmc.msu.ru/bgp</ref> Таким образом, удостоверенными экспериментальными данными являются только значения, полученные для случая 1 процесса. Значения для случаев 2 и 4 процессов являются ОЦЕНОЧНЫМИ и выводятся из результатов работы модифицированной версии алгоритма, исследуемой в <ref name = "exp">Parallel Algorithm for the Chameleon Clustering Algorithm using Dynamic Modeling. Rajnish Dashora, Harsh Bajaj, Akshat Dube, Geetha Mary .A. VIT University,Vellore. International Journal of Computer Applications (0975 – 8887) Volume 79 – No8, October 2013 </ref>. К сожалению, указанной реализации авторы не предоставляют.

[[File:CHAMELEON performance.png|800px]]

===Динамические характеристики и эффективность реализации алгоритма===
===Выводы для классов архитектур===
===Существующие реализации алгоритма===
С копией референсной реализации иерархической кластеризации, взятой с данного ресурса [http://us.codeforge.com/article/192925 Sequental], в случае неработоспособности последнего, можно ознакомиться здесь [http://pastebin.com/PhC4X0Cy Copy] 
Последовательная реализация алгоритма CHAMELEON использовалась в статье <ref>Clustering Of Web Usage Data Using
Chameleon Algorithm, T.Vijaya Kumar, Dr. H.S.Guruprasad, International Journal of Innovative Research in Computer
and Communication Engineering, Vol. 2, Issue 6, June 2014</ref>
Теоретически возможна реализация алгоритма CHAMELEON с использованием графовых библиотек, например [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS ], [http://glaros.dtc.umn.edu/gkhome/metis/hmetis/overview hMETIS] и [https://cran.r-project.org/web/packages/RANN/index.html RANN]. 
Параллельных реализаций алгоритма CHAMELEON в графовых библиотеках мною найдено не было. Однако существует исследование, связанное с реализацией CHAMELEON посредством технологии OpenMP, с которым можно ознакомиться здесь [http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf параллельная реализация].

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

<references \>

Краткий обзор алгоритма [http://studopedia.ru/7_41934_algoritm-dinamicheskoy-ierarhicheskoy-klasterizatsii-CHAMELEON.html|] 
Первоначальная статья от авторов алгоритма [http://www-users.cs.umn.edu/~han/dmclass/chameleon.pdf|] 
Исследования возможной параллелизации алгоритма[http://research.ijcaonline.org/volume79/number8/pxc3891600.pdf|]

Обсуждение участника:Chachba.A

2016-11-18T09:43:20Z

Kronberg: /* Замечания к статье "Быстрое дискретное преобразование Фурье" */

== Замечания к статье ==

* п.п. 1.8, 1.9 не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* в п.п. 2.4 следует добавить описание компьютерной платформы, текст исследуемой программы.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:41, 16 ноября 2016 (MSK)
** сделано

== Замечания к статье "Быстрое дискретное преобразование Фурье" ==

* Перенесите пожалуйста статью в личное пространство [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** а как это сделать? У нас нет прав на это, похоже
*** пункт 1 на этой странице, надо написать модератору: [[Алговики:Студенческие работы]]
* Раздел 1.1 - в самом первом абзаце стоит вставить обозначения двух фунций - f и f с крышкой, чтобы было ясно, что куда отображается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* В общее описание алгоритма нужно вставить слова именно об алгоритме, а не только о математической задаче. В чем быстрота, за счет чего она достигается и т.д. Тут, в отличие от математического описания, не стоит увлекаться формулами. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Раздел 1.2 - существует обозначение части формулы через эпсилон, однако в следующей формуле он не встречается, странно. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Нужно пояснение, что происходит, когда N не представимо в виде произведения: применим ли алгоритм и в каких изменениях он нуждается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
*** Обратите внимание на то, что объяснение других участников другое: [[Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье]]
* Нет данных о глубине рекурсии, написать об этом явно, скорее всего, в разделе "вычислительное ядро алгоритма". [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done

* Все хорошо, кроме переноса статьи (написал об этом) и дописывания разделов про программную реализацию алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 12:43, 18 ноября 2016 (MSK)

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-18T09:39:24Z

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

{{Assignment|IgorS}}
Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье, или спектром исходной функции, по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала, содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы «разделяй и властвуй». Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math> — число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> — простое число), то данный алгоритм не применим. На замену ему приходит алгоритм Радера, имеющий худшую асимптотику, нежели обычный БПФ, но лучшую чем <math>O(N^2)</math>. Также алгоритм Радера потребует дополнительного взаимодействия процессоров, что приведет к ухудшению эффективности.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

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

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

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

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Все запуски программы[http://pastebin.com/raw/xajKb9JN] проводились на с/к Blue Gene/P с использованием библиотеки Intel MKL.

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

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

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

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

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-18T09:35:39Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье, или спектром исходной функции, по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала, содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы «разделяй и властвуй». Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math>-число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> - простое число), то данный алгоритм не применим. На замену ему приходит алгоритм Радера, имеющий худшую асимптотику, нежели обычный БПФ, но лучшую чем <math>O(N^2)</math>. Также алгоритм Радера потребует дополнительного взаимодействия процессоров, что приведет к ухудшению эффективности.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

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

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

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

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Все запуски программы[http://pastebin.com/raw/xajKb9JN] проводились на с/к Blue Gene/P с использованием библиотеки Intel MKL.

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

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

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

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

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-18T09:34:29Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье, или спектром исходной функции, по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы "разделяй и властвуй". Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math>-число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> - простое число), то данный алгоритм не применим. На замену ему приходит алгоритм Радера, имеющий худшую асимптотику, нежели обычный БПФ, но лучшую чем <math>O(N^2)</math>. Также алгоритм Радера потребует дополнительного взаимодействия процессоров, что приведет к ухудшению эффективности.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

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

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

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

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Все запуски программы[http://pastebin.com/raw/xajKb9JN] проводились на с/к Blue Gene/P с использованием библиотеки Intel MKL.

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

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

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

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

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Обсуждение участника:Chachba.A

2016-11-18T09:33:12Z

Kronberg: /* Замечания к статье "Быстрое дискретное преобразование Фурье" */

== Замечания к статье ==

* п.п. 1.8, 1.9 не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* в п.п. 2.4 следует добавить описание компьютерной платформы, текст исследуемой программы.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:41, 16 ноября 2016 (MSK)
** сделано

== Замечания к статье "Быстрое дискретное преобразование Фурье" ==

* Перенесите пожалуйста статью в личное пространство [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** а как это сделать? У нас нет прав на это, похоже
*** пункт 1 на этой странице, надо написать модератору: [[Алговики:Студенческие работы]]
* Раздел 1.1 - в самом первом абзаце стоит вставить обозначения двух фунций - f и f с крышкой, чтобы было ясно, что куда отображается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* В общее описание алгоритма нужно вставить слова именно об алгоритме, а не только о математической задаче. В чем быстрота, за счет чего она достигается и т.д. Тут, в отличие от математического описания, не стоит увлекаться формулами. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Раздел 1.2 - существует обозначение части формулы через эпсилон, однако в следующей формуле он не встречается, странно. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Нужно пояснение, что происходит, когда N не представимо в виде произведения: применим ли алгоритм и в каких изменениях он нуждается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Нет данных о глубине рекурсии, написать об этом явно, скорее всего, в разделе "вычислительное ядро алгоритма". [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done

Обсуждение участника:Ivanov.kir.m

2016-11-18T09:30:04Z

Kronberg: /* Замечания к статье Быстрое дискретное преобразование Фурье */

== Замечания к статье ==

=== Неправильная структура статьи ===
* привести в соответствие 1 и 2 часть описания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено
* «рекурсивное описание» вынести в подпункт к основному пункту содержания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено

=== Отсутствующие части ===
* отсутствуют п.п. 2.2, 2.3, 2.5, 2.6--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Согласно постановке первого домашнего задания по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16 Сайт курса]) пункты 2.1, 2.2, 2.3, 2.5, 2.6 по общей структуре статьи (см. [http://algowiki-project.org/ru/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2 Структура описания свойств алгоритмов]) являются необязательными к заполнению (см. [http://parallel.ru/sites/default/files/info/education/superk-modelir-1-2016.pdf Первая лекция по курсу СкМиТ] слайд 62)
* отсутствует вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Указали в шапке статьи

=== Замечания по тексту ===
* п.п. 1.9 и 1.10 (в нумерации автора) не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Исправлено
* в п.п. 2.4 следует добавить описание компьютерной платформы--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:35, 16 ноября 2016 (MSK)
** Добавили

== Замечания к статье Быстрое дискретное преобразование Фурье ==

* В разделе "Общее описание алгоритма" следует вставить именно описание алгоритма. Потому что смысл алгоритма проясняется только в следующем разделе, а желательно иметь его общее (с минимумом формул) описание во введении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Стоит добавить слова о том, что происходит, когда размер массива не представим в виде произведения - можно ли тогда применять алгоритм, и если да, то какие изменения следует сделать [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Не вполне понятна логика использования курсива и полужирного начертания [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Не хватает данных о глубине рекурсии при использовании алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали

* Все хорошо, осталось только написать недостающие разделы по программной реализации алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 12:30, 18 ноября 2016 (MSK)

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-18T09:28:37Z

Kronberg: /* Рекурсивное описание */

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора — принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип «разделяй и властвуй», глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители, не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицей) до составного числа. В процессе слияния добавленные значения отбрасываются.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование проводилось на вычислительном комплексе IBM Blue Gene/P

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

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

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-18T09:28:03Z

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

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора — принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип «разделяй и властвуй», глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицией) до непростого числа. В процессе слияния добавленные значения отбрасываются.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование проводилось на вычислительном комплексе IBM Blue Gene/P

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

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

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-18T09:23:53Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора — принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип "разделяй и властвуй" глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицией) до непростого числа. В процессе слияния добавленные значения отбрасываются.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование проводилось на вычислительном комплексе IBM Blue Gene/P

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

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

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-18T09:22:37Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора - принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип "разделяй и властвуй" глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицией) до непростого числа. В процессе слияния добавленные значения отбрасываются.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование проводилось на вычислительном комплексе IBM Blue Gene/P

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

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

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

Обсуждение участника:Артем Таран

2016-11-14T13:26:19Z

Kronberg: /* Замечания к Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON */

== Замечания к [[Участник:Артем_Таран/Графо-ориентированный_алгоритм_кластеризации_CHAMELEON]] ==

* отсутствует оценка вычислительной мощности алгоритма в п 1.10

* В п.1.1. следует добавить информацию о том, известно ли число кластеров заранее [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:26, 14 ноября 2016 (MSK)

* В п.1.2. наверное стоит отнести параметр k к исходным данным [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:26, 14 ноября 2016 (MSK)

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

2016-11-14T11:09:01Z

Kronberg: /* Замечания к статье про Хамелеон (ещё порция) */ новая тема

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

2016-11-11T13:30:39Z

Kronberg: /* Замечания к статье "Алгоритм кластеризации с использованием представлений" */ новая тема

=== Замечания к статье ===

* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 16:04, 25 октября 2016 (MSK)

== Замечания к статье "Алгоритм кластеризации с использованием представлений" ==

* П.1.2. Мало сказано о входном наборе данных. Если это могут быть точки произвольной размерности, это надо формализовать [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)
* П.1.2. Не сказано, как именно выбираются точки-представители, чтобы они были максимально удалены, это нетривиально [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)
* не сказано об оптимальном выборе параметров алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)

Участник:Karibov/Алгоритм кластеризации с использованием представлений

2016-11-11T13:25:56Z

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

{{algorithm
| name = Алгоритм кластеризации с использованием представлений
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

Основные авторы описания: [[U:Karibov|Карибов Евгений]], [[U:x.kurashov|Курашов Александр]]

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

Назначение: кластеризация очень больших наборов числовых данных.

Ограничения: эффективен для данных низкой размерности, работает только на числовых данных.

Описание алгоритма [1]:

Шаг 1: Построение дерева кластеров, состоящего из каждой строки входного набора данных.

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

Шаг 3: Слияние ближних кластеров в один кластер. Новый кластер получает все точки входящих в
него входных данных. Расчет расстояния до остальных кластеров для новообразованного кластера. Для
расчета расстояния кластеры делятся на две группы: первая группа – кластеры, у которых ближайшими
кластерами считаются кластеры, входящие в новообразованный кластер, остальные кластеры – вторая
группа. И при этом для кластеров из первой группы, если расстояние до новообразованного кластера
меньше чем до предыдущего ближайшего кластера, то ближайший кластер меняется на новообразованный
кластер. В противном случае ищется новый ближайший кластер, но при этом не берутся кластеры,
расстояния до которых больше, чем до новообразованного кластера. Для кластеров второй группы
выполняется следующее: если расстояние до новообразованного кластера ближе, чем предыдущий
ближайший кластер, то ближайший кластер меняется. В противном случае ничего не происходит.

Шаг 4: Переход на шаг 3, если не получено требуемое количество кластеров.

== Математическое описание алгоритма ==
Исходные данные: множество данных <math>\{p_i\}</math>, <math>k</math> - число кластеров, на которое необходимо разбить множество, число точек представителей <math>c</math>, параметр <math>\alpha</math> для сжатия точек представления к центру кластера, <math>m</math> число точек для кластеризации, <math>n</math> - размерность множества, параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной инициализации.

Вычисляемые данные: множества <math>C_i, i = 1..k</math>

Формулы метода:

Для каждого <math>C_i</math> вычисляем центроид: <math>\mu _i = \frac{1}{n_i} \sum^{}_{j \in C_i} {j}</math>, <math>n_i </math> - количество точек в кластере <math>C_i</math>

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

<math>d_{mean}(C_i, C_j) = \left \|\mu _i - \mu _j\right \|</math>;

<math>d_{ave}(C_i, C_j) = \frac{1}{n_in_j} {\sum^{}_{p\in C_i} {\sum^{}_{p'\in C_j} {\left \|p - p'\right \|}}}</math>;

<math>d_{max}(C_i, C_j) = \max_{p'\in C_j, p'\in C_j}\left \|p - p'\right \|</math>;

<math>d_{min}(C_i, C_j) = \min_{p'\in C_j, p'\in C_j}\left \|p - p'\right \|</math>.

Объединяем ближайшие кластеры.

Затем для каждого кластера определяются <math>c</math> точек представителей максимально удалённых друг от друга.

Затем каждую точку представителя выполняется сдвигают к центроиде соответствующего кластера в <math>\alpha</math> раз.

Затем происходит присвоение неиспользованных точек к кластерам.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой итерационное построение <math>k</math> кластеров, вычисление их центроидов и назначение точек представителей.

== Макроструктура алгоритма ==
Основную часть метода составляют разбиение случайной выборки строк на <math>k</math> кластеров и нахождение точек-представителей для каждого кластера.

== Схема реализации последовательного алгоритма ==
[[Файл:CURE.jpg|800px|thumb|center|Рисунок 1. Схема реализации [2]]]

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

== Информационный граф ==
В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор, пока число кластеров не будет равно <math>k</math>.

[[Файл:IG_CURE.jpg|800px|thumb|center|Рисунок 2. Информационный граф]]

== Ресурс параллелизма алгоритма ==
Каждый шаг алгоритма выполняется независимо от других кластеров и их представителей. Это дает предпосылки к возможности хорошего распараллеливания метода кластеризации на каждом этапе алгоритма.

== Входные и выходные данные алгоритма ==
Входные данные: множество данных <math>\{p_i\}</math>, <math>k</math> - число кластеров, на которое необходимо разбить множество, число точек представителей <math>c</math>, параметр <math>\alpha</math> для сжатия точек представления к центру кластера, <math>m</math> число точек для кластеризации, <math>n</math> - размерность множества, параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной инициализации.

Выходные данные: множества <math>C_i, i = 1..k</math>

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

Недостатки: есть необходимость в задании пороговых значений и количества кластеров [1].

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

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

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

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

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

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

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

== Существующие реализации алгоритма ==
Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике [3].

= Литература =
[1] Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf.

[2] Guha, Sudipto; Rastogi, Rajeev; Shim, Kyuseok (2001). "CURE: An Efficient Clustering Algorithm for Large Databases" (PDF). Information Systems. 26 (1): 35–58. doi:10.1016/S0306-4379(01)00008-4.

[3] Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming. Volume 4315 of the series Lecture Notes in Computer Science pp 289-299 Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP.

[4] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002.

Обсуждение участника:Лукьянова Анна

2016-11-11T13:24:36Z

Kronberg: /* Замечания к статье "Алгоритм кластеризации с использованием представлений" */ новая тема

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: отсутствуют п.п. во 2 части--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 16:01, 25 октября 2016 (MSK)

== Замечания к статье "Алгоритм кластеризации с использованием представлений" ==

* п.1.1.1. Если взялись за классификацию алгоритмов, лучше разъяснить, что такое агломеративные, дивизивные, "четкие" и "нечеткие" алгоритмы. Было бы здорово даже сделать это в отдельной статье про задачу кластеризации, но это не обязательно [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.1.2. Метрики и некоторые подробности лучше перенести ниже, к "математическому описанию" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.2 выглядит дописанным не до конца. Там нужно разъяснить те неформальные конструкции, которые встречались ранее в п. 1.1.2. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.5. Псевдокод слишком псевдо, его следует сделать больше похожим на код, с соответствующим форматированием [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* следует добавить информацию об оптимальном выборе параметров алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)

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

2016-11-11T13:12:51Z

Kronberg:

= Статья [[Алгоритм кластеризации с использованием представлений]] =
* Не указан вклад каждого автора [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* В заголовках разделов 1 и 2 слово "ЧАСТЬ" лишнее [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.2 начиная с шага "Назначение представителей" математическое описание превращается в словесное [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.3 состоит из одного предложения, не дает разумной детализации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.4 состоит из одного предложения, не дает разумной детализации [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.5 состоит из одного рисунка, достаточность информации под вопросом [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.6 приведенные оценки сложности не обоснованы [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.7 приведен рисунок чего-то, отдаленно напоминающее информационный граф, для одного из шагов алгоритма, информационного графа для алгоритма в целом не приведено [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.8. не приведено оценок параллельной сложности алгоритма [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценок объема входных и выходных данных [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
** Не исправлено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* Ссылки на п. 1 и 2 из списка литературы в тексте отсутствуют [[Участник:Coctic|Coctic]] ([[Обсуждение участника:Coctic|обсуждение]]) 12:31, 25 октября 2016 (MSK)
* Исправлено
-----
Неисправленные замечания:

* п. 1.3 состоит из одного предложения, не дает разумной детализации [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.4 состоит из одного предложения, не дает разумной детализации [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.5 состоит из одной подписи к рисунку без самого рисунка, фактически пункт отсутствует [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK) - "Я нашёл небольшую опечатку: одном из блоков IF ветвь 'Нет' не была подписана. Попытался перезагрузить картинку несколько раз, но ничего не изменилось" [[Участник:Cookie|С. Шатков]] 12:04, 1 ноября 2016 (MSK)
* п. 1.7 приведен рисунок чего-то, отдаленно напоминающее информационный граф, для одного из шагов алгоритма, информационного графа для алгоритма в целом не приведено [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.8 не приведено оценок параллельной сложности алгоритма [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)
* п. 1.9 не приведено оценок объема входных и выходных данных [[Участник:Coctic|К. Стефанов]] ([[Обсуждение участника:Coctic|обсуждение]]) 11:03, 1 ноября 2016 (MSK)

* В п.1.1. следует явно указать, задается ли число кластеров h заранее, или вычисляется в процессе работы алгоритма. В п.1.4 об этом упомянуто, но нужно сказать раньше, так как это важное свойство [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:12, 11 ноября 2016 (MSK)
* Не хватает слов о том, из каких соображений выбираются параметры алгоритма, и как их оптимальных выбор зависит от ситуации. Интересуют параметры числа точек-представителей, альфа, гамма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:12, 11 ноября 2016 (MSK)
* Понятие "точка-представитель" лучше писать через дефис [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:12, 11 ноября 2016 (MSK)

Участник:JuliaA/Алгоритм кластеризации с использованием представлений

2016-11-11T12:56:28Z

Kronberg: /* Общее описание алгоритма */

Основные авторы описания: 
[[Участник:JuliaA|Ю.А. Антохина]], разделы [[#Общее описание алгоритма|1.1]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]] - [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]] 

[[Участник:Cookie|С.А. Шатков]], разделы [[#Математическое описание алгоритма|1.2]] - [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Масштабируемость алгоритма и его реализации|2.4]] 

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

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

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

Результат кластеризации зависит от того, как будут представлены кластеры. Например, средним всех точек кластера, или всеми точками кластера. Применение среднего возможно только в евклидовом пространстве. А использование всех точек неустойчиво к случайным выбросам. В CURE используется другой метод: для каждого кластера выбираются точки-представители. Выбирается постоянное число точек, которые будут представлять каждый кластер. Кластеры с наиболее похожими наборами репрезентативных точек объединяются на каждом шаге алгоритма.

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

Описание шагов

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

'''Шаг 2'''. Для каждого кластера выбираем <math>c</math> точек представителей, максимально удаленных друг от друга. Чисто <math>c</math> остается постоянным.

'''Шаг 3'''. Объединяем кластеры с наиболее похожими наборами точек представителей.
Если не достигнуто нужное число кластеров, то перейти на шаг 2.
Чтобы при объединении кластеров не выбирать каждый раз c точек представителей из всех точек, мы выбираем их только из <math>2c</math> точек объединенных кластеров.

Выбранные точки сдвигаются на следующем шаге на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Exampleofalgorithmparametrs1.png|400px|thumb|center|Пример работы алгоритма для разных параметров <math>\alpha</math> [1].]]

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

Пусть дана матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>. Каждая строка матрицы представляет собой точку в <math>n</math> - мерном пространстве.

m число точек для кластеризации, n размерность.

Расстояние <math>\rho(a,b)</math> между точками <math>a = (a_{1},\dots,a_{n})</math> и <math>b = (b_{1},\dots,b_{n})</math> будем вычислять по формуле:

<math>\rho(a,b) = \sqrt{\sum_{i=1}^n (a_{i} - b_{i})^2}</math>

'''Шаг "Инициализация"'''

Выбираются <math>\lceil \gamma m\rceil</math> строк матрицы случайным образом. Например, можно использовать [https://ru.wikipedia.org/wiki/Reservoir_sampling Алгоритм R].

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

'''Шаг "Кластеризация"'''

В самом начале шага считаем каждую выбранную точку одноточечным кластером с центроидой в этой же точке.

Далее выполняем следующие шаги 1-2, пока количество кластеров не станет равно <math>h</math>:

Шаг 1:

Для каждого <math>i</math>-го кластера вычисляется центроида <math>\mu_{i}</math> по формуле:

<math>\mu_{i} = \frac{1}{s_{i}}\sum_{j\in S_{i}} x^{j}</math>, где <math>S_{i}</math> - номера строк матрицы <math>x</math>, входящие в <math>i</math>-й кластер; <math>s_{i}</math> - количество элементов в множестве <math>S_{i}</math>; <math>x^{j}</math> - <math>j</math>-я строка матрицы <math>x</math>.

Шаг 2:

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

'''Шаг "Назначение представителей"'''

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

Для этого используем следующий алгоритм:

Пусть <math>i</math> - текущее количество представителей, <math>S_{k}</math> - множество номеров строк матрицы <math>x</math>, входящие в <math>k</math>-й кластер, <math>R_{k}</math> - множество номеров строк матрицы <math>x</math>, назначенных представителями <math>k</math>-го кластера, а <math>x^{j}</math> - вектор-строка матрицы <math>x</math>, задающая точку в <math>n</math>-мерном пространстве.

<math>R_{k}</math> = [] % Пустое множество
a = Choose(<math>S_{k}</math>) % Выбор произвольного номера точки, входящей в кластер <math>k</math>
Add(<math>R_{k}</math>,a) % Добавление точки а во множество представителей
i = 1 % Текущее количество представителей кластера
While (i<c) do % Хотим найти с представителей для кластера
- rmax = 0
- For ( (y <math>\in</math> <math>S_{k}</math>) and (y <math>\notin</math> <math>P_{k}</math>) ) do % Поиск следующего представителя среди оставшихся точек кластера
- - rmin = <math>\rho(x^{a}</math>,<math>x^{y})</math>
- - For ( (j <math>\in</math> <math>R_{k}</math>) and (j <math>\neq</math> a) ) do % Поиск расстояния от точки с номером y до ближайшего представителя
- - - d = <math>\rho(x^{j}</math>,<math>x^{y})</math> % вычисление расстояния
- - - If (d < rmin) then
- - - - rmin = d
- - - endif
- - enddo
- - If (rmin > rmax) % Поиск точки, для которой расстояние до ближайшего представителя является максимальным
- - - rmax = rmin
- - - b = y % искомая точка
- - endif
- enddo
- Add(<math>R_{k}</math>,b) % Добавление новой точки в множество представителей
- i = i + 1 % текущее число представителей
enddo
</math>

'''Шаг "Сдвиг представителей к центроиде"'''

Для каждого представителя <math>x^{y}</math> из <math>k</math>-го кластера выполняется сдвиг к его центроиде <math>\mu_{k}</math> в <math>\alpha</math> раз:

<math>\hat{x}^{y} = \alpha\mu_{k} + (1-\alpha)x^{y}</math>.

Получаем множество <math>\hat{R}_{k}</math> из <math>c</math> точек, которые будут далее использоваться как представители этого кластера.

'''Шаг "Присваивание"'''

На данном шаге происходит присвоение неиспользованных точек (строк матрицы <math>x</math>) к кластерам. Для точки-строки <math>p</math> вычисляется расстояние до каждого представителя. Результат: строка <math>p</math> добавляется в поддерево кластера, которому принадлежит наиближайший представитель.

Результатом работы алгоритма является дерево, ветвями которого являются отдельные кластеры. Листьями кластеров являются строки из матрицы <math>x</math>.

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

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

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

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

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

[[Файл:SubCURE4.jpg|1100px|thumb|center|Схема работы алгоритма кластеризации CURE]]

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

Входные данные для кластеризации - это <math>n</math> репрезентативных точек в d мерном пространстве и необходимое число <math>h</math> кластеров. Для каждой точки необходимо вычислить расстояние до другой. Сложность этого этапа <math>O(n)</math>. Если искать ближайший кластер простым перебором, то сложность поиска будет <math>O(n)</math> для каждого кластера. Но для эффективного поиска сложность составляет <math>log_2{n}</math>. Эффективный метод описан в статье.<ref>Sudipto Guha (Stanford), Rajeev Rastogi (Bell Labs), Kyuseok Shim (Korea Institute of Technology). CURE: an efficient clustering algorithm for large databases. SIGMOD '98 Proceedings of the 1998 ACM SIGMOD international conference on Management of data, pp 73-84 </ref> Далее каждую точку необходимо вдвинуть к центроиде, сложность этой операции <math>O(2)</math>.
Таким образом худшее время выполнения алгоритма <math>O(n^2 log_2{n})</math>. Для двумерного пространства временная сложность может быть <math>O(n^2)</math>. Так что сложность алгоритма не хуже чем у центроидного. То есть при такой размерности входных данных CURE выполняется за полиномиальное время.<math>~^{[1]}</math>

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

'''Шаг "Инициализация"'''

В зависимости от алгоритма случайная выборка номеров строк матрицы <math>x</math> может производится либо зависимо, либо независимо друг от друга.

'''Шаг "Кластеризация"'''

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

'''Шаг "Назначение представителей"'''

[[Файл:Points c.png|800px|thumb|center|Последовательный информационный граф для точек-представителей]]

'''Шаг "Сдвиг представителей к центроиде"'''

Данный шаг выполняется независимо для каждой точки-представителя каждого кластера.

'''Шаг "Присваивание"'''

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

Основные шаги алгоритма информационно зависят от предыдущих шагов.

[[Файл:InfoCURE.jpg|1100px|thumb|center|Общий информационных граф алгоритма]]

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

'''Шаг "Кластеризация"'''

Шаг 1 (вычисление центроид):

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

Шаг 2 (поиск "наилучших кластеров для объединения):

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

'''Шаг "Назначение представителей"'''

Представители внутри каждого кластера определяются независимо от других кластеров и поддаются распараллеливанию.

'''Шаг "Сдвиг представителей к центроиде"'''

Изменение положения представителей можно сделать независимо как от представителей данного кластера, так и представителей других кластеров. Это также хорошо поддаётся распараллеливанию.

'''Шаг "Присваивание"'''

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

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

Входные данные: матрица <math>x \in R^{m\times n}</math>, количество кластеров <math>h</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>.

<math>m</math> число точек для кластеризации, <math>n</math> размерность.

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

Параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной выборке точек на шаге "Инициализация".

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

[[Файл:Exampleofalgorithmparameters2.png|400px|thumb|center|Пример работы алгоритма для разных параметров <math>c</math>.]]

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

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

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

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

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

'''Недостатки''': есть необходимость в задании пороговых значений и количества кластеров, работает только на числовых данных, эффективен только для данных низкой размерности

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

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

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

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

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

Данный раздел будет заполнен к 15 ноября.

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

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

== Существующие реализации алгоритма ==
Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике <ref>Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP</ref>. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

<references \>

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

2016-11-11T11:08:12Z

Kronberg: /* Замечания к статье "Алгоритм быстрого дискретного преобразования Фурье" */ новая тема

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: неверная нумерация, отсутствуют п.п.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)

== Замечания к статье "Алгоритм быстрого дискретного преобразования Фурье" ==

* Раздел 1.1 - вместо общего описания алгоритма написано именно что математическое описание. В общем описании должна быть поставлена задача и изложена основная идея, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Раздел 1.2 - не очень ясны слова про "проиллюстрированные на рисунке 2 в разделе Информационный граф". Раздел "Информационный граф" содержит рисунок 1. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Если упоминаем рекурсию, нужны слова о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-11T11:07:28Z

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

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

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

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

Напомним формулу ДПФ:

<math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>

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

* Преобразование входного массива данных (бит-реверсирование).
* Вычисление БПФ.
Приведем более детальное описание БПФ (математическое описание):
*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>.

В конечном итоге мы пришли к конечной формуле для первого этапа вычисления БПФ. Дальнейшие этапы делят подмножества полученные на предыдущим этапе вычисления БПФ.

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

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 2'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 2 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-11T11:07:00Z

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

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

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

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

Напомним формулу ДПФ:

<math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>

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

* Преобразование входного массива данных (бит-реверсирование).
* Вычисление БПФ.
Приведем более детальное описание БПФ (математическое описание):
*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>.

В конечном итоге мы пришли к конечной формуле для первого этапа вычисления БПФ. Дальнейшие этапы делят подмножества полученные на предыдущим этапе вычисления БПФ.

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

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 2'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 2 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>. Где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-11T11:06:35Z

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

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

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

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

Напомним формулу ДПФ:

<math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>

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

* Преобразование входного массива данных (бит-реверсирование).
* Вычисление БПФ.
Приведем более детальное описание БПФ (математическое описание):
*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>.

В конечном итоге мы пришли к конечной формуле для первого этапа вычисления БПФ. Дальнейшие этапы делят подмножества полученные на предыдущим этапе вычисления БПФ.

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

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 2'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 2 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>. Где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>. Где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

Участник:Kronberg

2016-11-11T10:57:18Z

Kronberg: Новая страница: «Кронберг Дмитрий Анатольевич, к.ф.-м.н., ассистент кафедры суперкомпьютеров и квантовой и…»

Кронберг Дмитрий Анатольевич, к.ф.-м.н., ассистент кафедры суперкомпьютеров и квантовой информатики ВМК МГУ.

Обсуждение участника:Victoria Stepanischeva

2016-11-11T10:56:32Z

Kronberg: /* Замечания к статье "Быстрое преобразование Фурье" */ новая тема

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* Раздел про общее описание алгоритма слишком большой и нарезан на много частей. Было бы лучше написать статью про саму задачу преобразования Фурье, где и упоминались бы в частности области применения, а также разные алгоритмы с краткими описаниями (а впоследствии со ссылками на статьи с полным описанием) [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)
* При упоминании рекурсивного решения задачи следует сказать о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)

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

2016-11-11T10:49:48Z

Kronberg: /* Замечания к статье "Быстрое преобразование Фурье" */

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

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

2016-11-11T10:46:07Z

Kronberg: /* Замечания к статье "Быстрое преобразование Фурье" */ новая тема

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В обозначении эпсилона не хватает индекса, к которому он привязан (встретится в дальнейшем) [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

Обсуждение участника:Chachba.A

2016-11-11T10:31:20Z

Kronberg: /* Замечания к статье "Быстрое дискретное преобразование Фурье" */ новая тема

== Замечания к статье ==

* п.п. 1.8, 1.9 не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено

== Замечания к статье "Быстрое дискретное преобразование Фурье" ==

* Перенесите пожалуйста статью в личное пространство [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
* Раздел 1.1 - в самом первом абзаце стоит вставить обозначения двух фунций - f и f с крышкой, чтобы было ясно, что куда отображается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
* В общее описание алгоритма нужно вставить слова именно об алгоритме, а не только о математической задаче. В чем быстрота, за счет чего она достигается и т.д. Тут, в отличие от математического описания, не стоит увлекаться формулами. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
* Раздел 1.2 - существует обозначение части формулы через эпсилон, однако в следующей формуле он не встречается, странно [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
* Нужно пояснение, что происходит, когда N не представимо в виде произведения: применим ли алгоритм и в каких изменениях он нуждается [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
* Нет данных о глубине рекурсии, написать об этом явно, скорее всего, в разделе "вычислительное ядро алгоритма" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-11T10:23:42Z

Kronberg: /* Общее описание алгоритма */

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-11T10:15:13Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
Преобразование Фурье переводит сигнал в его спектр и обратно, и широко
применяется в самых различных областях вычислительной математики —
собственно спектральный анализ, сжатие данных, вычисление свёрток и
т.д. В связи с этим, особый интерес представляют быстрые алгоритмы для
вычисления этого преобразования. На сегодняшний день наилучшие из
них имеют сложность <math>O(n \log n)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math>.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k\,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

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

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math>. В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

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

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

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

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

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

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

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

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

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

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

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

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

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

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

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

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

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

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

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

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

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

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

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

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

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-11T10:14:47Z

Kronberg: /* Общее описание алгоритма */

{{Assignment|IgorS}}
{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
Преобразование Фурье переводит сигнал в его спектр и обратно, и широко
применяется в самых различных областях вычислительной математики —
собственно спектральный анализ, сжатие данных, вычисление свёрток и
т.д. В связи с этим, особый интерес представляют быстрые алгоритмы для
вычисления этого преобразование. На сегодняшний день, наилучшие из
них имеют сложность <math>O(n \log n)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math>.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k\,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

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

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math>. В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

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

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

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

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

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

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

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

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

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

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

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

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

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

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

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

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

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

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

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

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

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

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

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

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

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Обсуждение участника:Ivanov.kir.m

2016-11-11T10:13:17Z

Kronberg: /* Замечания к статье Быстрое дискретное преобразование Фурье */

== Замечания к статье ==

=== Неправильная структура статьи ===
* привести в соответствие 1 и 2 часть описания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено
* «рекурсивное описание» вынести в подпункт к основному пункту содержания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено

=== Отсутствующие части ===
* отсутствуют п.п. 2.2, 2.3, 2.5, 2.6--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Согласно постановке первого домашнего задания по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16 Сайт курса]) пункты 2.1, 2.2, 2.3, 2.5, 2.6 по общей структуре статьи (см. [http://algowiki-project.org/ru/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2 Структура описания свойств алгоритмов]) являются необязательными к заполнению (см. [http://parallel.ru/sites/default/files/info/education/superk-modelir-1-2016.pdf Первая лекция по курсу СкМиТ] слайд 62)
* отсутствует вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Указали в шапке статьи

=== Замечания по тексту ===
* п.п. 1.9 и 1.10 (в нумерации автора) не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Исправлено

== Замечания к статье Быстрое дискретное преобразование Фурье ==

* В разделе "Общее описание алгоритма" следует вставить именно описание алгоритма. Потому что смысл алгоритма проясняется только в следующем разделе, а желательно иметь его общее (с минимумом формул) описание во введении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Стоит добавить слова о том, что происходит, когда размер массива не представим в виде произведения - можно ли тогда применять алгоритм, и если да, то какие изменения следует сделать [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Не вполне понятна логика использования курсива и полужирного начертания [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Не хватает данных о глубине рекурсии при использовании алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

Обсуждение участника:Ivanov.kir.m

2016-11-11T10:12:58Z

Kronberg: /* Замечания к статье Быстрое дискретное преобразование Фурье */

== Замечания к статье ==

=== Неправильная структура статьи ===
* привести в соответствие 1 и 2 часть описания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено
* «рекурсивное описание» вынести в подпункт к основному пункту содержания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено

=== Отсутствующие части ===
* отсутствуют п.п. 2.2, 2.3, 2.5, 2.6--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Согласно постановке первого домашнего задания по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16 Сайт курса]) пункты 2.1, 2.2, 2.3, 2.5, 2.6 по общей структуре статьи (см. [http://algowiki-project.org/ru/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2 Структура описания свойств алгоритмов]) являются необязательными к заполнению (см. [http://parallel.ru/sites/default/files/info/education/superk-modelir-1-2016.pdf Первая лекция по курсу СкМиТ] слайд 62)
* отсутствует вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Указали в шапке статьи

=== Замечания по тексту ===
* п.п. 1.9 и 1.10 (в нумерации автора) не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Исправлено

== Замечания к статье Быстрое дискретное преобразование Фурье ==

* В разделе "Общее описание алгоритма" следует вставить именно описание алгоритма. Потому что смысл алгоритма проясняется только в следующем разделе, а желательно иметь его общее (с минимумом формул) описание во введении[[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Стоит добавить слова о том, что происходит, когда размер массива не представим в виде произведения - можно ли тогда применять алгоритм, и если да, то какие изменения следует сделать[[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Не вполне понятна логика использования курсива и полужирного начертания[[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

* Не хватает данных о глубине рекурсии при использовании алгоритма[[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)

Обсуждение участника:Ivanov.kir.m

2016-11-11T10:11:04Z

Kronberg: /* Замечания к статье Быстрое дискретное преобразование Фурье */ новая тема

== Замечания к статье ==

=== Неправильная структура статьи ===
* привести в соответствие 1 и 2 часть описания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено
* «рекурсивное описание» вынести в подпункт к основному пункту содержания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено

=== Отсутствующие части ===
* отсутствуют п.п. 2.2, 2.3, 2.5, 2.6--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Согласно постановке первого домашнего задания по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16 Сайт курса]) пункты 2.1, 2.2, 2.3, 2.5, 2.6 по общей структуре статьи (см. [http://algowiki-project.org/ru/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2 Структура описания свойств алгоритмов]) являются необязательными к заполнению (см. [http://parallel.ru/sites/default/files/info/education/superk-modelir-1-2016.pdf Первая лекция по курсу СкМиТ] слайд 62)
* отсутствует вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Указали в шапке статьи

=== Замечания по тексту ===
* п.п. 1.9 и 1.10 (в нумерации автора) не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Исправлено

== Замечания к статье Быстрое дискретное преобразование Фурье ==

* В разделе "Общее описание алгоритма" следует вставить именно описание алгоритма. Потому что смысл алгоритма проясняется только в следующем разделе, а желательно иметь его общее (с минимумом формул) описание во введении

* Стоит добавить слова о том, что происходит, когда размер массива не представим в виде произведения - можно ли тогда применять алгоритм, и если да, то какие изменения следует сделать

* Не вполне понятна логика использования курсива и полужирного начертания

* Не хватает данных о глубине рекурсии при использовании алгоритма

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-11T10:01:38Z

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

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''FFTW''', написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай - алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет '''эрмитовой избыточности''' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на '''''поворотные множители''''' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

'''Замечание:''' Как правило все '''''поворотные множители''''' вычисляются заранее и хранятся в специальном массиве.

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

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор '''''комплексных''''' чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В '''общем случае''' :

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению '''''свёртки''''', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. '''Итого для дискретного преобразования Фурье требуется''' <math>O(N\log(N))</math> '''действий для любого''' <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

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

Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

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

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)