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

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

2016-12-15T11:33:53Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(m2^{2m})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

Основные авторы описания: [[U:Khotkin|Хоткин Кирилл]] 623 гр., [[U:Mikhail Tsarev|Царев Михаил]] 615 гр.

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

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

'''Матрица Адамара''' <math>H</math> порядка <math>n</math> представляет собой матрицу размера ''n''×''n'' из элементов <math>+1</math> и <math>-1</math>, такую, что: <math>H \cdot H^T = n \cdot E_n,</math>
где <math>E_n</math> — это единичная матрица размера ''n''×''n''.

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

Матрица Адамара остаётся матрицей Адамара при следующих преобразованиях:
* умножение строчки или столбца на −1;
* перестановка строчек или столбцов местами.

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

Матрица Адамара называется нормализованной, если её первая строка и столбец состоят только из единиц.

Под матрицией Адамара <math>H_m</math> подразумевается матрица порядка <math>2^m</math>

Примерами матриц Адамара различных размеров являются следующие матрицы:

<math>H_0 = (1);</math>

<math>H_1 =
\begin{pmatrix} 1 & 1
\\1 & -1
\end{pmatrix};
</math>

<math>H_2 =
\begin{pmatrix} 1 & 1 & 1 & 1
\\1 & -1 & 1 & -1
\\1 & 1 &- 1 & -1
\\1 & -1 & -1 & 1
\end{pmatrix}.
</math>

Вообще, если <math>H_m</math> матрица Адамара порядка <math>2^m</math>, то матрица
<math>H_{m+1} =
\begin{pmatrix} H_m & H_m
\\H_m & -H_m
\end{pmatrix}
</math>
является матрицей Адамара порядка <math>2^{m+1}</math>

Кроме того, матрицу Адамара порядка <math>2^m</math> можно получить по следующей формуле <math>H^{\otimes m} = H_1 \otimes ... \otimes H_1</math>, где знак <math> \otimes </math> означает тензорное произведение.

Также существует недоказанная гипотеза Адамара, которая утверждает, что существуют матрицы Адамара порядка <math>4k</math> для любого натурального <math>k</math>, однако матрица Адамара порядка <math>268</math> до сих пор не построена, как и для ряда других порядков больше <math>268</math>. Поэтому в данной работе будут рассматриваться матрицы Адамара порядка <math>2^m</math>.

=== Математическое описание алгоритма ===
Описанные ранее способы построения матрицы Адамара не являются оптимальными, поэтому вычисление матрицы Адамара порядка <math>2^m</math> будет производится поэлементно с помощью следующей формулы:

<math>
(H_m)_{ij}=(-1)^ {\sum_{k}{(i \& j)_k}},
</math>

где <math>\& - </math> побитовая операция И,

<math>(i \& j)_k - </math> <math>k</math> -ый разряд в двоичном представлении числа <math>(i \& j)</math>.

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является вычисление элементов матрицы Адамара:

<math>
(H_m)_{ij}=(-1)^ {\sum_{k}{(i \& j)_k}}.
</math>

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

<math>(-1)^ {\sum_{k}{(i \& j)_k}}.</math>

=== Схема реализации последовательного алгоритма ===
Для вычисления очередного элемента матрицы Адамара нужно выполнить следующие шаги:

1. Побитовое умножение <math>i</math> и <math>j</math>: <math>result = i \& j </math> ;

2. Нахождение числа единиц в двоичной записи числа <math>result </math>: <math> sum = \sum_{k}{(result)_k} </math>;

3. Нахождение элемента матрицы Адамара: <math>(H_m)_{ij}=(-1)^{sum}</math>.

Возможная реализация на языке C++:

<source lang="C">

int get_sign(unsigned N) {
int i;
for (i=0; N; N>>=1) { i+=N&1;}
return (i&1) ? -1 : 1;
}
void adamar(int **e, int size) {
for (unsigned int i = 0; i < size; ++i)
for (unsigned int j = 0; j < size; ++j)
e[i][j]=get_sign(i&j);
}
</source>

=== Последовательная сложность алгоритма ===
Для выполнения первого шага алгоритма для всех элементов матрицы Адамара необходимо суммарно выполнить:
* <math>2^{2m}</math> операций побитового умножения.
На втором шаге алгоритма необходимо выполнить для каждого элемента матрицы Адамара:
* от 0 до m или m логических сдвигов на один бит в зависимости от программной реализации;
* от 0 до m или m операций сложения в зависимости от программной реализации;
* от 0 до m или m операций логического умножения в зависимости от программной реализации.
На третьем шаге для всех элементов необходимо сумарно выполнить:
* <math>2^{2m}</math> операций побитового умножения;
* <math>2^{2m}</math> операций сравнения с нулем.

Взяв в расчет не самую лучшую программную реализацию второго шага, всего потребуется выполнение следующего количества операций:
* <math>(m+2)2^{2m}</math> операций логического умножения;
* <math>m\cdot2^{2m}</math> операций сложения;
* <math>m\cdot2^{2m}</math> операций логического сдвига на один бит;
* <math>2^{2m}</math> операций сравнения с нулем.
Всего <math>(3m+3)2^{2m}</math> операций.

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

На рисунке ниже изображен информационный граф алгоритма.

*<math>i\&j</math> - операция побитового умножения, где <math>i</math> и <math>j</math> соответствующие координаты элемента <math>h_{ij}</math>;
* NoO (number of ones) - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций сложения и побитового умножения;
* Sign - определение знака соответствующего элемента. Если результат предыдущего шага - чётное число, то знак положительный, иначе - отрицательный.

[[File:Hadamar matrix.png|thumb|center|1400px|Рисунок 1. Граф алгоритма построения матрицы Адамара.]]

=== Ресурс параллелизма алгоритма ===
Вычисление любого элемента можно производить независимо от других, то есть параллельно.

Высота канонической ярусно-параллельной формы равна 3.
Ширина ЯПФ равна <math>2^{2m}</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': m - размерность матрицы <math>H_m</math>.

'''Объём входных данных''': 1 (число m).

'''Выходные данные''': матрица Адамара <math>H_{m}</math> размерностью <math>2^m</math>.

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

=== Свойства алгоритма ===
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{(3m+3)2^{2m}}{1+2^{2m}}\, \approx 3m+3.</math>;
* Алгоритм построения матрицы Адамара является ''недетерминированным'', так как число операций меняется в зависимости от входных данных (числа m, которое формирует матрицу размерности 2''m'' × 2''m'');
* Данный алгоритм построения матрицы Адамара является ''несбалансированным''. Так как каждый элемент матрицы может обрабатываться независимо от других, вычисление элементов можно распределить по процессам. В случае, когда количество элементов матрицы <math>n</math> не кратно количеству процессов <math>s</math>, на некоторые процессы ложится дополнительная задача вычисления элементов матрицы в количестве <math>a=n\operatorname{mod}s</math>.

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

Учитывая, что рассматриваемый алгоритм строит симметричные матрицы Адамара, можно уменьшить количество вычисляемых элементов c <math>2^{2n}</math> до <math>\frac{2^n+2^{2n}}{2}</math> путем вычисления только диагональных и наддиагональных элементов.

=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
В ходе данной работы все вычислительные эксперименты были проведены на суперкомпьютере IBM Blue Gene/P. В суперкомпьютере насчитывается 2048 вычислительных узлов. Каждый вычислительный узел состоит из одного четырехъядерного PowerPC 450 процессора. Таким образом всего насчитывается 8192 процессорных ядер. Пиковая производительность составляет 27,9 терафлопс. На вычислительных узлах системы Blue Gene/P возможны три режима исполнения процессов: 1. режим симметричного мультипроцессора (symmetrical multiprocessing, SMP) 2. режим виртуальных вычислительных узлов (virtual node mode, VN) 3. режим двухъядерных вычислительных узлов (dual node mode, DUAL) Таким образом на вычислительном узле могут быть размещены один, четыре и два MPI процесса. В VN и DUAL режимах процессы в рамках вычислительного узла для обмена данными могут использовать механизм общей памяти. Вычислительный эксперимент проводился в режиме SMP.

Параметрами запуска реализации алгоритма были число процессов и порядок матрицы, которые менялись в диапазонах [<math>2^0, 2^1,..., 2^i,..., 2^{10}</math>] и [<math>2^5, 2^6,..., 2^j,..., 2^{14}</math>] соответственно. При осуществлении реализации алгоритма на каждом узле компьютера размещалось по одному процессу, таким образом при увеличении числа процессов увеличивалось и число задействованных узлов.

На рисунках ниже представлены графики производительности и эффективности параллелизма реализации алгоритма построения матрицы Адамара произвольного размера.

[[file:Productivity.jpg|thumb|center|1000px|Рисунок 2. График производительности реализации алгоритма.]]
[[file:Parallel_efficiency.jpg|thumb|center|1000px|Рисунок 3. График эффективности параллелизма реализации алгоритма.]]

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];

== Литература ==
[1] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

Участник:Руслан/Плотностный алгоритм кластеризации

2016-12-01T11:09:11Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основной автор описания: [[User:Руслан|Кучеров Р.И.]]

Алгоритм '''DBSCAN (Density Based Spatial Clustering of Applications with Noise)''' - плотностный алгоритм для кластеризации пространственных данных с присутствием шума), был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы. Большинство алгоритмов, производящих плоское разбиение, создают кластеры по форме близкие к сферическим, так как минимизируют расстояние до центра кластера. Авторы DBSCAN экспериментально показали, что их алгоритм способен распознать кластеры различной формы.

= ЧАСТЬ. Свойства и структура алгоритма =
Кластеризация – это процесс разбиения множества элементов на непересекающиеся кластеры, так, чтобы в каждом кластере все элементы были схожи в каком-то смысле, а объекты разных кластеров существенно отличались.

== Общее описание алгоритма ==
Идея, положенная в основу алгоритма, заключается в том, что внутри каждого кластера наблюдается типичная плотность точек (объектов), которая заметно выше, чем плотность снаружи кластера, а также плотность в областях с шумом ниже плотности любого из кластеров. Ещё точнее, что для каждой точки кластера её соседство заданного радиуса должно содержать не менее некоторого числа точек, это число точек задаётся пороговым значением. Алгоритм DBSCAN для заданных значений параметров <math>\varepsilon</math> и MinPts исследует кластер следующим образом: сначала выбирает случайную точку, являющуюся ядровой, в качестве затравки, затем помещает в кластер саму затравку и все точки, плотно-достижимые из неё.

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

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных.

Для построения оценки плотности, на основе соседства точек вводятся понятия достижимости и связности. Под <math>\varepsilon</math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math> , т. е. <math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}.</math> Тогда точка y достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:

<math>\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon</math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы. При такой постановке задачи, под кластером понимается максимальное связное подмножество множества X . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительное ядро последовательной версии зависти от поиска всех точек в <math>\varepsilon</math>-окрестности конкретной точки. Из-за поиска <math>\varepsilon</math>-соседства алгоритм имеет квадратичную вычислительную сложность <math>O(n^2)</math> (где n - количество точек). Но если задействовать K-мерное дерево, то можно снизить сложность до <math>O(\text{n log n})</math>.

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

Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Это может быть R*-дерево или k-d дерево. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Также для построения этих деревьев нужно уметь находить расстояние между объектами <math>\rho(u, v)</math> , в, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}.</math>

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

Алгоритм начинает работу с произвольной точки <math>x \in X</math> и возвращает <math>\varepsilon</math> -окрестность(строка 4). Если <math>\varepsilon</math>-окрестность содержит, как минимум minpts точек, процедура выдает новый кластер C. Алгоритм извлекает все точки в X, которые являются плотность достижима из x и добавляет их в кластер C(строки 8-17). Если в <math>\varepsilon</math>-окрестности x точек меньше, чем minpts, то x помечается как шум(строка 6). Однако, х все еще может быть добавлены в кластер, если она определится как пограничная точка во время изучения других основных точек(строки 16-17). Поиск точек в <math>\varepsilon</math>-окрестности(функция GETNEIGHBORS)известен, как запрос в диапазоне значений и получает все плотностно достижимые точки от главной точки(строки 8-17) известный как алгоритм наращивания областей. Заметим что кластер может быть определен однозначно, начиная с любой "ядровой" точки<ref> A. Zhou, S. Zhou, J. Cao, Y. Fan, and Y. Hu, “Approaches for scaling DBSCAN algorithm to large spatial databases,” Journal of computer science and technology, vol. 15, no. 6, pp. 509–526, 2000.</ref>.

1: procedure DBSCAN(X, eps, minpts)
2: for each unvisited point x ∈ X do
3: mark x as visited
4: N ← GETNEIGHBORS(x, eps)
5: if |N| < minpts then
6: mark x as noise
7: else
8: C ← {x}
9: for each point x' ∈ N do
10: N ← N \ x'
11: if x' is not visited then
12: mark x' as visited
13: N' ← GETNEIGHBORS(x', eps)
14: if |N'| ≥ minpts then
15: N ← N ∪ N'
16: if x' is not yet member of any cluster then
17: C ← C ∪ {x'}

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

В общем случае алгоритм DBSCAN имеет квадратичную вычислительную сложность <math>O(n^2)</math>(где n это количество точек в X) из-за поиска <math>\varepsilon</math>-соседства. Но если использовать пространственную индексацию (например, использую k-мерное дерево<ref>M. B. Kennel, “KDTREE 2: Fortran 95 and C++ software to efficiently search for near neighbors in a multi-dimensional Euclidean space,” 2004, institute for Nonlinear Science, University of California.</ref> или R-дерево) для поиска <math>\varepsilon</math>-соседства, сложность снижается до <math>O(n log n)</math><ref>J. Bentley, “Multidimensional binary search trees used for associative searching,” Communications of the ACM, vol. 18, no. 9, pp. 509–517, 1975.</ref>.

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

На рисунке 1 представлен информационный граф алгоритма кластеризации DBSCAN. На входе у нас множество точек <math>P_i</math> и мы пробегаем по всем непосещенным точкам. Далее мы, для каждой непосещенной точки, маркируем ее как посещенную и находим всех её <math>\varepsilon</math>-соседей(на графике это узел <math>G</math>). Добавляем точку к кластеру(узел <math>C</math>). Затем, пробегаем по всем плотностно-достижимых точках(<math>P_j</math>) к нашей точке, и для каждой такой точки ищем <math>\varepsilon</math>-сосдей и добавляем их в кластер, если они ещё не принадлежат никакому кластеру.

[[file:Информационный_граф.png|thumb|center|700px|Рис.1 Граф алгоритма без отображения входных и выходных данных. <math>P_i</math> и <math>P_j</math> - точки данного множества, <math>G</math> - поиск <math>\varepsilon</math>-соседей, <math>C</math> - добавление элемента к кластеру.]]

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

Поиск <math>\varepsilon</math>-соседей требует вычисления n расстояний и выполнения n сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит O(1). Так как поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит O(n).

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

Входные данные: набор точек x, пороговое расстояние <math>\varepsilon</math>, а также минимальное количество точек, необходимых для формирования кластера, minpts.

Выход: множество кластеров С.

Если указать маленькое значение <math>\varepsilon</math>, то все точки будут шумом. Если наоборот, сделать большое значение, то кластер не будет разбит, возьмет один кластер и включит в него все точки. Также, если взять minpts слишком большое или слишком маленькое, будет либо один кластер, либо все точки шумовые. Оптимальные значения находятся опытным путем.

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

=== Преимущества алгоритма ===
* не требует указать априори количество кластеров, в отличие от K-средства

* алгоритм может разбить на произвольной формы кластеры. Даже может выявить кластер находящийся внутри другого, но не пересекающийся с ним. Из-за параметра MinPts снижается так называемый эффект однолокальности(single-link)

* алгоритм имеет понятие "шума" и устойчив к выбросам

* алгоритм требует всего два параметра и в основном нечувствительны к упорядоченности изначально данных точек

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

=== Недостатки алгоритма ===

* алгоритм не совсем детерминирован: пограничные точки, которые доступны из более чем одного кластера могут быть частью любого кластера, в зависимости от того, как происходит обработка данных. К счастью, эта ситуация не часто возникают, и мало влияет на результат кластеризации. На основных точках и точках "шума", алгоритм детерминирован. Есть DBSCAN<ref>Campello, R. J. G. B.; Moulavi, D.; Sander, J. (2013). Density-Based Clustering Based on Hierarchical Density Estimates. Proceedings of the 17th Pacific-Asia Conference on Knowledge Discovery in Databases, PAKDD 2013. Lecture Notes in Computer Science. p. 160.</ref> который представляет собой вариант, который рассматривает пограничные пункты как шум, и таким образом достигается полностью детерминированный результат, а также более последовательной статистической интерпретации плотности соединенных компонентов.

* качество алогоритма зависит от меры, которую мы рассматриваем в пространстве. Наиболее распространенная мера использует евклидово расстояние.

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

* алгоритм не может кластеризовать данные хорошо с большими различиями в плотности

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

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

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

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

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

Было проведено исследование масштабируемости параллельной реализации алгоритма DBSCAN. Исследование проводилось на суперкомпьютере "Ломоносов". Исследовалась параллельная реализация алгоритма, написанная с использованием стандарта MPI. Распараллеливание проводилось по числу входных объектов.

[[file:DbscanPerfomance.png|thumb|center|700px|Рис.2 График масштабируемости]]

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

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

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

[https://github.com/ruslanmsk/parallel_dbscan Параллельная реализация на языке C++]

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

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

== Существующие реализации алгоритма ==
[//en.wikipedia.org/wiki/ELKI ELKI] предлагает реализацию DBSCAN, а также GDBSCAN и другие варианты. Эта реализация может использовать различные структуры индексов для поквадратного выполнения и поддерживает произвольное расстояние функции и произвольные типы данных, но это можно обогнать низкоуровневой оптимизацией реализации на небольших наборах данных.

[//en.wikipedia.org/wiki/Scikit-learn Scikit-Learn] включает в себя реализацию Python для DBSCAN для произвольной метрики Минковского, который может быть ускорен с помощью KD-деревьев и шаровых деревьев, но который использует в худшем случае квадратичную память.

[//en.wikipedia.org/wiki/R_(programming_language) GNU R] содержит DBSCAN в [//cran.r-project.org/web/packages/fpc/index.html fpc] пакете с поддержкой произвольных функций расстояния через матриц. Однако он не имеет поддержки индекса (и, соответственно, имеет квадратичное время выполнения и сложность по памяти) и довольно медленно из-за интерпретации R. Более быстрая версия реализована на языке C++ с использованием KD-деревьев (только когда расстояние Евклидово ) в пакете R [//cran.r-project.org/web/packages/dbscan/index.html dbscan].

[//www.philippe-fournier-viger.com/spmf/SPMF SPMF] предлагает GPL-V3 java-реализацию алгоритма DBSCAN с поддержкой KD-дерева (только для параметра расстояние Евклида).

[//en.wikipedia.org/wiki/Weka_(machine_learning) Weka] содержит (как дополнительный пакет в последних версиях) базовую реализацию DBSCAN, которая работает за квадратичное время и линейную память.

[//en.wikipedia.org/wiki/Apache_Commons Apache Commons Мath] содержит java-реализацию алгоритма выполняющегося за квадратичное время.

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

* Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.

* Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.

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

* Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.

Участник:Маркова Екатерина/Построение матрицы Адамара

2016-12-01T11:07:31Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(N^2)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>4</math>
| input_data = <math>1</math>
| output_data = <math>N^2</math>
}}
Основной автор статьи: Маркова Е.А. 615 гр.
== Свойства и структура алгоритма ==
=== Общее описание алгоритма===

Матрица Адамара <math>H</math> - это квадратная матрица размера <math>N\times N</math>, составленная из чисел <math>1</math> и <math>-1</math>, столбцы которой ортогональны, так что справедливо соотношение:

<math>H*H^T = N*E_N</math>,

где <math>E_N</math> - это единичная матрица размера <math>N</math>. Матрицы Адамара применяются в различных областях, включая комбинаторику, численный анализ, обработку сигналов.

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

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

Пусть <math>H_m</math> <math>-</math> матрица Адамара порядка <math>2^m</math> и <math>-H_m</math> <math>-</math> матрица с противоположными элементами. Тогда матрица <math>H_{2m}</math> получается следующим образом:
<math>H_{2m} = \begin{bmatrix}
H_m & H_m \\
H_m & -H_m
\end{bmatrix}
</math>

Данным алгоритм описывает получение матриц Адамара только порядка степени 2, то есть <math>m</math> и <math>N</math> связаны соотношением <math>N = 2^m</math>.

Получение матрицы порядка <math>N</math> состоит из следующих <math>m</math> шагов:

Шаг 1: <math>H_1 = (1);</math>

Шаг 2: <math>H_2 =
\begin{pmatrix} 1 & 1
\\1 & -1
\end{pmatrix};
</math>

Шаг 3: <math>H_3 =
\begin{pmatrix} 1 & 1 & 1 & 1
\\1 & -1 & 1 & -1
\\1 & 1 &- 1 & -1
\\1 & -1 & -1 & 1
\end{pmatrix}.
</math>

...

Шаг <math>m</math>: искомая матрица <math>H_m</math>.

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

Вычислительное ядро рекурсивного алгоритма состоит из <math>\;N^2\;</math> присвоений значений матрицы Адамара

<math>H_{1,1} = 1</math>;

<math>H_{ij} = H_{i(j - \frac{N}{2})}</math>, где <math>i = 1..\frac{N}{2}</math>, <math>j = \frac{N}{2}+1..N</math>;

<math>H_{ij} = H_{(i-\frac{N}{2})j}</math>, где <math>i = \frac{N}{2}+1..N</math>, <math>j = 1.. \frac{N}{2}</math>;

<math>H_{ij} = H_{(i-\frac{N}{2})(j-\frac{N}{2})}</math>, где <math>i = \frac{N}{2}+1..N </math>, <math>j = \frac{N}{2}+1..N</math>.

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

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

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

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

Сначала заполняется правый верхний блок матрицы <math>H</math>

<math>H_{ij} = H_{i(j - \frac{N}{2})}</math>, где <math>i = 1..\frac{N}{2}</math>, <math>j = \frac{N}{2}+1..N</math>;

затем левый нижний блок

<math>H_{ij} = H_{(i-\frac{N}{2})j}</math>, где <math>i = \frac{N}{2}+1..N</math>, <math>j = 1.. \frac{N}{2}</math>.

Последним заполняется нижний правый блок матрицы

<math>H_{ij} = H_{(i-\frac{N}{2})(j-\frac{N}{2})}</math>, где <math>i = \frac{N}{2}+1..N </math>, <math>j = \frac{N}{2}+1..N</math>.

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

Для заполнения матрицы <math>H</math> размера <math>N\times N</math> необходимо <math>\;N^2\;</math> присвоений значений. Из чего можно сделать вывод, что рекурсивный метод построения матрицы Адамара является алгоритмом с ''квадратичной сложностью''.

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

[[file:111.jpeg|thumb|center|500px|Рисунок 1. Граф отображает шаг, стрелками показаны пересылки данных, в узлах происходит операция присвоения значений и инверсия.]]

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

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

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

Входные данные: <math>N</math> - размерность матрицы.

Объем входных данных: 1.

Выходные данные: матрица размером <math>N\times N</math>.

Объем выходных данных: <math> N^2</math>.

===Свойства алгоритма===
Вычислительная мощность алгоритма равна суммарному объему входных и выходных данных: <math>N^2 + 1</math>.

Алгоритм полностью детерминирован.

Не смотря на существование недоказанной гипотезы, что существует алгоритм, способный построить матрицы Адамара, размера кратного 4, данный алгоритм вычисляет только матрицы размера степени 2.

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

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

Исследование проводилось на [http://cluster2.inm.ras.ru кластере ИВМ].

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

* число процессоров [1:32];
* размер матрицы [32: 16384].

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

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

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

Построим оценки масштабируемости выбранной реализации построения матрицы Адамара:
* По числу процессоров:
[[Файл:EQP8kY4D9E0.jpg|thumb|center|700px|Рисунок 2. Масштабируемость по числу процессоров. По оси ОХ отложено количество процессоров, по оси ОУ - величина производительности для разного размера матрицы.]]
* По размеру задачи:
[[Файл:PmIAoJaqnO8.jpg|thumb|center|700px|Рисунок 3. Масштабируемость по размеру задачи. По оси ОХ отложена размерность матрицы, по оси ОУ - величина производительности для разного количества процессоров]]
* По двум направлениям:
[[Файл:Khm.jpg|thumb|center|700px|Рисунок 4. Масштабируемость по двум направлениям. По ОХ - количество процессоров, по ОУ - размерность матрицы, по OZ - величина производительности при изменении в двух направлениях.]]
[[Файл:untitled.jpg|thumb|center|700px|Рисунок 5. Параллельная реализация построения матрицы Адамара. Изменение производительности в зависимости от числа процессоров и размера матрицы.]]

[https://www.dropbox.com/s/1ga1fp26nztt65n/hadamard_2.c?dl=0 Исследованная реализация на языке C]

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

Реализация
[https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB]

Реализация
[http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ PYTHON]

Реализация
[https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM]

На языке ''Java'' реализован класс ''Hadamard'' не входящий в стандарт языка. С кодом можно ознакомиться по [https://gist.github.com/guitarkitten/3937264 ссылке].

== Литература ==
1. Мак-Вильямс Ф., Слоэн Н. — "Теория кодов, исправляющих ошибки" (1979)

2. Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — "Алгебраический аппарат квантовой информатики 2"

3. М. Н. Аршинов, Л. Е. Садовский — "Коды и математика" (1983)

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

2016-12-01T11:07:18Z

Sleo: Полностью удалено содержимое страницы

Участник:Nikita/Построение матрицы Адамара

2016-12-01T10:57:33Z

Sleo:

{{Assignment|Sleo}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

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

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

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

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

2016-12-01T10:56:55Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара произвольного размера
| serial_complexity = <math>O(n*(2^{n})^2))</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O((2^n)^2)</math>
| input_data = <math>1</math>
| output_data = <math>(2^n)^2</math>
}}

Работу выполнил студент 611 группы Раев Евгений.

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

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

'''Матрица Адамара''' <math>H</math> — это квадратная матрица размера ''n''×''n'', составленная из чисел 1 и −1, столбцы которой ортогональны, так что справедливо соотношение
: <math>H \cdot H^T = n \cdot E_n,</math>
где <math>E_n</math> — это единичная матрица размера ''n''. Матрицы Адамара применяются в различных областях, включая комбинаторику, численный анализ, обработку сигналов.

'''Матрица оператора Адамара''' имееет вид
:<math>\begin{align}
H = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Соответственно, существует итерационная формула нахождения матриц Адамара, через тензорное произведение матрицы оператора Адамара на матрицу Адамара меньшего порядка:
:<math>H_n = H_{1} \otimes H_{n-1}</math>, где знак <math> \otimes </math> означает тензорное произведение.

Мы будем использовать в дальнейшем нормализованную матрицу оператора Адамара, без коэффицента (для удобности вывода):
:<math>\begin{align}
H =
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Представим пример высчитывания матриц Адамара:
:<math>
H_{0} = 1,
</math>

:<math>
H_{1} = H_{1} \otimes H_{0} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes 1 = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix},
</math>

:<math>
H_{2} = H_{1} \otimes H_{1} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>

:<math>
H_{3} = H_{1} \otimes H_{2} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>

Таким образом, получаем последовательность матриц Адамамра размерностью <math>2^n</math>

<math>H^{\otimes n} = H_1 \otimes ... \otimes H_1</math> (Описано в<ref>Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).</ref>).

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

Тензорное произведение довольно затратно для реализации на вычислительной технике (необходимо хранить в памяти матрицу предыдущего порядка), поэтому существует формула для определения элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum ij}</math>, где <math>i</math> и <math>j</math> - битовые представляения значений индексов, а <math>i j</math> - побитовое умножение. (Описано в <ref>Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2</ref>)
То есть, знак элемента матрицы Адамара зависит от количества едининц в побитовом произведении индексов - если это число чётное - то знак положительный, если нечётное - отрицательный.

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

Вычислительное ядро расчете элементов матрицы Адамара это вычисление элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum i j}</math>
Данная операция независима для каждого элемента, соответственно именно она подлежит распараллеливанию.

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

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

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

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

1. Определение индексов находимого элемента матрицы Адамара: <math>i</math> и <math>j</math>.

2. Побитовое умножение индексов : <math>res = ij</math>.

3. Подсчет количества значащих единиц в <math>res</math>: <math>count = \sum res</math>.

4. Получение знака элемента по его четности: <math>sign = (-1)^{count}</math>.

Данному алгоритму соответствует приведенный ниже код на языке С++:
<source lang="C">
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

int get_sign(int i, int j) //Get sign Hadamard matrix's element by indices
{
int res = i & j;
int count;
for (count=0; res; res>>=1)
{
if (res & 1)
count++;
}
if (count & 1 ==1)
return -1;
else
return 1;
}

int print_HadamardMatrix(int N) //print Hadamard matrix 2^n size
{
int matr_size(pow(2,N));
for (int i = 0; i < matr_size; i++)
{
for (int j = 0; j < matr_size; j++)
{

if (get_sign(i,j)==1)
cout <<" 1 ";
else
cout <<"-1 ";
}
cout << endl;
}
cout << endl;
return 0;
}

int main(int argc, const char * argv[])
{
if(argc!=2)
{
printf("Matrix size missing\n");
return 1;
}
int N(atoi(argv[1]));
print_HadamardMatrix(N);

return 0;
}
</source>

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

Построение матрицы Адамара порядка <math>2^n</math> требует рассчета <math>(2^{n})^2</math> элементов матрицы. Это включает в себя:

1. <math>(2^{n})^2</math> побитовых умножений индексов элемента <math>i \& j</math>.

2. Операция определения значащих единиц, состоит из последовательных сдвигов и умножений на 1. В худшем случае, если мы будет рассчитывать элемент с координатам <math>(2^n-1,2^n-1)</math> будет произведено n операций сдвига (так как число <math>2^n-1 </math> кодируется n битами), и n операций умножения на 1 (для определения значащей единицы). То есть не более чем <math>2\cdot n\cdot(2^{n})^2 </math> операций на данном шаге.

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

Следовательно, общая последовательная сложность алгоритма, равна <math>(2^{n})^2 +2\cdot n\cdot(2^{n})^2 + 2^(2^{n})^2</math>, то есть <math>(2^{n})^2(2+2n)</math>, или <math>O(n*(2^{n})^2))</math>

=== Информационный граф ===
На рисунке ниже изображен информационный граф алгоритма. Всего возможно <math>(2^n)^2</math> параллельных ветвей, так как каждый элемент матрицы может считаться независимо друг от друга.
[[File:GraphHamadard.jpg|thumb|center|800px|Рисунок 1. Двухмерная модель алгоритма.]]

[[File:Raev_graph2.jpg|thumb|center|800px|Рисунок 1. Трехмерная модель алгоритма. In - взодные данные, Out - результаты, <math> \& </math> - операция умножения,<math> \sum </math> - операция подсчета значащих единиц,<math> \pm </math> - операция определения знака элемента по четности]]

1. Операция <math> \& </math> - побитовое умножение индексов.<math>ij</math>, где <math>i</math> и <math>j</math> соответствующие координаты элемента <math>h_{kl}</math>;

2. Операция <math> \sum </math> -подсчет количества значащих единиц. Состоит из последовательных сдвигов и побитового умножения с 1.

3. Операция <math> \pm </math> - определение четности количества значащих единиц. Состоит из побитового умножения количества значащих единиц с 1.

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

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

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

Ширина ярусно-параллельной формы будет равна <math>O((2^n)^2)</math> - количество рассчитываемых элементов.
Высота ярусно-параллельной формы будет равна <math>O(2+2n)=O(n)</math>
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Одно натуральное число n. Данный алгоритм на основе этого числа строит матрицу Адамара <math>H_n</math> размерности <math>2^{n}\times 2^{n}</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': <math>2^{n}\cdot 2^n</math> чисел, которые представляют собой элементы <math>H_{i,j}</math> матрицы Адамара <math>H_{n}</math> размерности <math>2^{n}\times 2^{n}</math>. Вообще говоря, в силу симметричности матрицы Адамара, можно хранить только половину от этих данных, но алгоритм в статье не предполагает такой оптимизации).

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

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

* Соотношение последовательной и параллельной сложности можно определить как отношение высоты ярусно-параллельной формы и общей последовательно сложности, то есть <math>\frac{ (2+2n)(2^n)^2 }{2+2n} = (2^n)^2 </math>. Таким образом, соотношение - экспоненциально.

* Алогритм построения матрицы Адамара не является детерминированным.

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

<math>\frac{ (2^{n})^2(2+2n) } {1+(2^{n})^2 } </math> ( то есть <math>\approx 2n</math> если <math>n -> +\infty</math>)

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

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

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

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

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

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

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

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

==== Масштабируемость алгоритма и его реализации ====
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов»<ref>http://parallel.ru/cluster</ref>. Объектом исследования стала собственная реализация алгоритма с использованием средств MPI.
Наблюдались две переменные - время выполнения алгоритма и количество выполненных операций. Паратметры запуска - это размерность <math>2^N</math> матрицы Адамара и количество процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров: [2,32] с шагом 2;
*размер матрицы: степени двойки в диапазоне [2, 16] с шагом 1, то есть, реальная размерность матрицы была в диапазоне [4, 65536].

Ниже представлен график времени работы от изменения входных параметров. Как видно, оптимизация программы с ростом числа процессоров идет довольно быстро.
[[Файл:raev_time.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

Так как в нашем алгоритме существенно мало операция с плавающей точкой, в качестве альтернативы Flops использовалось значение [https://en.wikipedia.org/wiki/Instructions_per_second#Millions_of_instructions_per_second MIPS] . График производительности:
[[Файл:raev_perfomance.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[[Файл:raev_perfomance1.png|500px|thumb|center|Неравномерное увеличение производительности]]

[https://github.com/analyzehim/parallel/blob/master/Task%201/task.cpp Исследованная параллельная реализация на языке C++]

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

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

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

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

* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram]
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy]

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

Участник:Огнева Мария/Метод встречи посередине

2016-11-13T23:29:23Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Метод встречи посередине
| serial_complexity = <math>O(\sqrt n\log n)</math>
| pf_height = <math>2</math>
| pf_width = <math>n</math>
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Автор описания: [[Участник:Maria rojas|М.С. Огнева]]

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

== Общее описание алгоритма ==
Криптоанализом назвают науку восстановления (дешифрования) открытого (нешифрованного) текста без доступа к ключу. Попытка криптоанализа называется атакой.

'''Методом встречи посередине''' (англ. meet-in-the-middle attack) называется класс атак на криптографические алгоритмы (алгоритмы шифрования), которые асимптотически уменьшают время полного перебора по всем ключам, но при этом увеличивают объем требуемой памяти. Впервые данный метод был предложен Уитфилдом Диффи и Мартином Хеллманом в 1977 году <ref>Diffie Whitfield, Hellman Martin E. ''Exhaustive Cryptanalysis of the NBS Data Encryption Standard.'' - Journal Computer vol.10 pp.74–84 - June 1977</ref> для блочных шифров.
=== История ===
Алгоритм шифрования [https://ru.wikipedia.org/wiki/DES DES] был принят в качестве стандарта в 1977 году. Длина ключа нового стандарта составляла 56 бит, довольно большое число по тем временам, но оставляла возможность полного перебора (<math>2^{56} </math>). В 1977 Диффи и Хеллман предложили устройство, стоимостью примерно 20 млн. долларов, которое смогло бы найти ключ DES за один день. Поэтому появилась необходимость увеличить стойкость алгоритма DES, используя технику многократного шифрования. Этот способ позволяет искусственно увеличить длину ключа, применяя несколько раз операцию шифрования с разными ключами. Так для алгоритма 2DES (двойное шифрование) длина ключа равна 112 бит, то есть полный перебор становится бессмысленной затеей.
В 1981 году Ральф Меркл и Мартин Хеллман<ref>Merkle Ralph C., Hellman Martin E. ''On the security of multiple encryption.'' - Journal Communications of the ACM, num.7 vol.24 pp.465-467 - July 1981</ref> подробно разбирают безопасность двойного шифрования и описывают метод встречи посередине, позволяющий восстановить ключ шифрования не за <math>2^{112}</math> операций шифрования, а за относительно пустяковые <math>2^{57}</math> за счет перебора не одного длинного ключа, а двух более коротких. Следующая модернизация DES - Triple DES с 168-битным ключом - требует от метода встречи посередине <math>2^{56} </math> памяти и <math>2^{112}</math> операций.

=== Особенности метода ===
# Способ шифрования: симметричный.
#:Для шифрования и расшифрования применяется один и тот же криптографический ключ.
# Условия криптоанализа: атака на основе открытого текста.
#:Известны открытый и шифрованный текст, алгоритм шифрования и дешифрования, необходимо найти ключ.
# Метод криптоанализа: универсальный.
#:С определенными вариациями метод применим ко многим шифрам.
# Применим для любого многократного шифрования одним алгоритмом по разным ключам, а также для случая, если множество ключей криптографического алгоритма замкнуто относительно композиции (для любых ключей k' и k" найдется ключ k такой, что результат шифрования любого текста последовательно на k' и k" равен результату шифрования того же текста на k).

=== Описание метода для алгоритма двойного шифрования ===
На данной странице будет рассмотрен более простой вариант - двойное шифрование <ref>Грушо А.А., Применко Э.А., Тимонина Е.Е. ''Анализ и синтез криптоалгоритмов. Курс лекций.'' - Москва: 2000. - 110 с.</ref> (две итерации шифрования). Пусть <math>p, c</math> – открытый (plaintext) и шифрованный текст (ciphertext) соответственно. Тогда сокращение полного перебора происходит следующим образом:
#Находим множество всех шифртекстов <math>W</math>, получаемых одинарным шифрованием открытого текста <math>p</math> по всем возможным ключам первой итерации.
#Находим множество всех шифртекстов <math>Z</math>, получаемых одинарным дешифрованием шифрованного текста <math>c</math> по всем возможным ключам второй итерации.
#Если множества <math>W</math> и <math>Z</math> имеют непустое пересечение, то искомым ключом шифрования будет являться пара ключей, при помощи которых это пересечение было зашифровано из <math>p</math> и дешифровано из <math>c</math>.

== Математическое описание алгоритма ==
Пусть алгоритм шифрования описывается как <math>Enc(k, t) </math>, дешифрования <math>Dec(k, t) </math>, где <math>k</math> – ключ, <math>t</math> – текст.
Тогда получаемый двойным шифрованием по ключам <math>k_1</math> и <math>k_2</math> шифрованный текст равен: <math>c = Enc(k_2, Enc(k_1, p))</math>.
Открытый текст получается из шифрованного двойным дешифрованием: <math>p=Dec(k_1, Dec(k_2, c))</math>.

'''Исходные данные:''' тексты <math>p, c</math>.

'''Вычисляемые данные:''' ключ <math>k=(k_1, k_2)</math>, где <math>k_1 \in K_1</math>, <math>k_2 \in K_2</math>.
Предположим для упрощения, что для известной пары <math>(p, c)</math> существует единственный ключ <math>(k_1, k_2)</math>.
Составим таблицы <math>W</math> и <math>Z</math>:
*для всех <math>k^i_1 \in K_1</math>: <math>w(k^i_1) = Enc (k^i_1, p)</math>
*для всех <math>k^j_2 \in K_2</math>: <math>z(k^j_2) = Dec (k^j_2, c)</math>
Таблицы объединяются и сортируются по полученным промежуточным шифртекстам <math>z_i, w_j</math>. Пара <math>z_i = w_j</math>, которую можно найти одиночным просмотром объединенной таблицы, определяет искомый ключ <math>(k^i_1, k^j_2) </math>.

В более общем случае, может получиться не одна пара <math>z_i = w_j</math>. Тогда необходимы еще пары <math>(p, c)</math> для определения истинного ключа.

== Вычислительное ядро алгоритма ==
Основную сложность алгоритма составляет перебор ключей <math>k^i_1,k^j_2</math>, а так же сортировка полученных массивов <math>W</math> и <math>Z</math>.

== Макроструктура алгоритма ==
Метод использует в качестве составных частей следующие алгоритмы:
# Алгоритм зашифрования/расшифрования
#*В качестве основных примем алгоритмы [https://ru.wikipedia.org/wiki/Blowfish Blowfish] и [https://ru.wikipedia.org/wiki/DES DES], сложность которых пропорциональна длине ключа. В связи с тем, что длина ключа не больше 64 бит, то будем считать, что эти алгоритмы выполняются за единицу времени.
# Алгоритм сортировки
#*Будем считать, что используется быстрая сортировка или сортировка слиянием, которые в среднем работают за <math>O(n \log n)</math>.
#Алгоритм поиска
#*Совпадающие значения матриц <math>W</math> и <math>Z</math> будем искать одиночным просмотром всей таблицы.

== Схема реализации последовательного алгоритма ==
Последовательность действий метода:
# Вычислить таблицы <math>W</math> и <math>Z</math>, записывая значения в порядке вычисления и сохраняя соответствующие ключи для шифрования/дешифрования.
# Отсортировать массив <math>W \cup Z</math>.
# Найти совпадения в отсортированной таблице.

== Последовательная сложность алгоритма ==
# Сложность вычисления таблиц <math>W</math> и <math>Z</math> составит <math>O(|K_1|+|K_2|)</math> операций.
# Объединение таблиц и их сортировка будет иметь сложность: <math>O([|K_1|+|K_2|]\log[|K_1|+|K_2|])</math>.
# Поиск совпадений: <math>O(|K_1|+|K_2|)</math>.
Общая сложность всего метода равна: <math>O(|K_1|+|K_2|) + O([|K_1|+|K_2|]\log[|K_1|+|K_2|]) + O(|K_1|+|K_2|)=O([|K_1|+|K_2|]\log[|K_1|+|K_2|])</math>

Примем за <math>n</math> количество всевозможных ключей <math>k= (k_1,k_2)</math>. Если предположить, что <math>|K_1|=|K_2|</math>, то <math>|K_1|=|K_2|=\sqrt n</math>.
Тогда сложность метода составит <math>O(\sqrt n\log n) </math>.

== Информационный граф ==
Опишем информационный граф алгоритма.

На вход подаётся открытый и шифрованный тексты. После открытый текст шифруется (Enc) по всем ключам <math>k_1</math>, а дешифрованный дешифруется (Dec) по всем ключам <math>k_2</math>. Далее полученные тексты сравниваются между собой (Cmp) и все ключи, на которых они совпали, являются выходами алгоритма.

[[file:Graph MITM.jpg|thumb|center|600px|Рисунок 1. Граф алгоритма c отображением входных и выходных данных. Plaintext — открытый текст, ciphertext — шифрованный текст, Enc — операция шифрования, Dec — операция дешифрования, Cmp — операция сравнения, Key — полученный ключ]]

== Ресурс параллелизма алгоритма ==
Как видно из информационного графа, для реализации метода в параллельном варианте потребуется выполнение следующих двух ярусов ярусно-параллельной формы (ЯПФ):
# <math>2* \sqrt{n}</math> шифрований/дешифрований
# <math>n</math> сравнений

То есть, высота ЯПФ составляет <math>2</math>, ширина – <math>n</math> (т.к. <math>n> 2* \sqrt n</math>).

== Входные и выходные данные алгоритма ==
'''Входные данные''': открытый текст <math>p</math> и шифрованный текст <math>c</math>, имеющие одинаковую длину.

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

Примем, что длина ключей <math>k_1</math> и <math>k_2</math> равна 64 битам. То есть длина текста равна 64 битам или кратна этому числу.

'''Выходные данные''': множество пар <math>(k_1,k_2)</math>, для которых нашлись совпадения.

Лишние пары могли получиться при шифровании/дешифровании одного из блоков текстов. Тогда для получения истинного ключа необходимо проверить все пары на блоках открытого и шифрованного текста, которые в алгоритме не использовались.

Длина искомого ключа: 128 бит.

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности для данного метода равно <math>O(\sqrt n\log n)</math>.

При этом вычислительная мощность алгоритма, равная отношению числа операций к суммарному объему входных и выходных данных, составляет <math>O(\sqrt{n})</math>.

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

Дуги информационного графа, исходящие из вершин, соответствующих операциям шифрования/дешифрования, образуют пучки мощности <math>\sqrt{n}</math>.

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

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

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

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

== Существующие реализации алгоритма ==
Реализаций метода в виде библиотек не обнаружено.
В свободном доступе существуют коды для метода встречи посередине с использованием шифрования Blowfish и хэш-таблиц на [https://gist.github.com/dchest/1062437 C], а также с использованием шифрования 2DES на [https://github.com/le1ca/class-resources/blob/master/ddes/ddes.py питоне].

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

[[Категория:Криптографические алгоритмы]]
*[https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B2%D1%81%D1%82%D1%80%D0%B5%D1%87%D0%B8_%D0%BF%D0%BE%D1%81%D0%B5%D1%80%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5 Метод встречи посередине]
*[https://en.wikipedia.org/wiki/Meet-in-the-middle_attack Meet-in-the-middle attack]

'''Сноски:'''

Участник:Elmon/Плотностный алгоритм кластеризации DBSCAN

2016-11-13T23:25:04Z

Sleo:

{{Assignment|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|H| \log |H|)</math>
| pf_width = <math>O(w)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основной автор описания: [[User:Elmon|Гилевич В.В.]]

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

== Общее описание алгоритма ==
Кластеризация — это процедура, упорядочивающая элементы из некоторого множества в сравнительно однородные группы (кластеры). Элементы могут содержать числовые, категориальные или смешанные данные. Плотностные методы выделяют кластеры на основе следующей идеи: кластером считается регион с высокой плотностью объектов, которые разделены разреженными регионами (с низкой плотностью объектов)

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996.</ref> — плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения данных на кластеры произвольной формы.

Алгоритм имеет ряд отличительных свойств:
* Не требуется заранее определять число кластеров
* Может отличать кластеры, которые нельзя разделить прямой линией (плоскостью, для N-мерного пространства), в том числе кластера, частично или полностью окруженные другим кластером.
* Хорошо работает в условиях зашумленных входных данных

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

=== Исходные данные ===
Множество <math>X</math>, на котором определена функция расстояния <math>D</math>.

=== Вычисляемые данные===
Множество пар из элемента множества <math>X</math>, и соответствующий ему номер кластера.

=== Параметры алгоритма ===
* <math>\varepsilon</math> — максимальное расстояние между соседями;
* <math>MinPts</math> — минимальное количество элементов находящихся <math>\varepsilon</math>-окрестности данного элемента для создания кластера.

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

* ''ядровой элемент'': элемент <math>p</math> является ядровым, если количество элементов в <math>\varepsilon</math>-окрестности, включая сам элемент <math>p</math> больше или равно <math>MinPts</math>;

* ''достижимость напрямую элемента <math>p</math> из элемента q'': элемент <math>p</math> считается достижимым напрямую из элемента <math>q</math>, если элемент <math>q</math> является ядровым, а элемент <math>p</math> находится в <math>\varepsilon</math>-окрестности элемента q;

* ''достижимость элемента <math>p</math> из элемента <math>q</math>'': элемент <math>p</math> достижим из элемента <math>q</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, где <math>p_{i + 1}</math> напрямую достижим из <math>p_{i}</math>;

* ''шум'': все элементы, недостижимые из какого-либо другого считаются шумом.

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

* ''связанность элемента p и элемента q'': элемент <math>p</math> считается связанным с <math>q</math>, если существует такой элемент <math>o</math>, что <math>p</math> и <math>q</math> достижимы из него.

Таким образом ''кластер'' должен удовлетворять двум условиям:
* Все элементы внутри кластера взаимно связанны;
* Если элемент связан с каким-либо элементом кластера, то он тоже является частью кластера.

[[File:DBSCAN-Illustration.svg|thumb|right|400px| Рис. 1. Для ''MinPts'' = 4. Красные элементы соответствуют ядровым, желтые — достижимым, синяя — шуму.<ref>https://en.wikipedia.org/wiki/DBSCAN Density-based spatial clustering of applications with noise (DBSCAN)</ref>]]

=== Пошаговое описание алгоритма ===

#Выбирается произвольная непосещенный элемент <math>p</math>.
#Элемент <math>p</math> помечается как посещенный.
#Проверяется, является ли элемент <math>p</math> ядровым.
#*Если элемент <math>p</math> является ядровым, то:
#**Он становится началом нового кластера или сохраняет номер кластера, который был присвоен элементу ранее;
#**Все элементы из <math>\varepsilon</math>-окрестности элемента <math>p</math> добавляются в его кластер (им присваевается номер кластера элемента <math>p</math>);
#**Процесс продолжается рекурсивно для каждого непосещенного элемента текущего кластера c шага 2.
#*Если элемент <math>p</math> не является ядровым, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является поиск элементов в <math>\varepsilon</math>-окрестности каждого элемента входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как для каждого элемента необходимо выполнить эту операцию. Основные операции вычислительного ядра алгоритма: нахождение расстояние между элементами множества и сравнение его с порогом для определения того, являются ли один элемент достижимым напрямую из другого.

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

Алгоритм DBSCAN предполагает использование пространственной структуры данных (структуры, ориентированной на индексацию многомерной информации, такой как географические данные) — такие структуры позволяют найти все элементы в пределах определенного расстояния от текущего за <math>O(\log n)</math>. Сложность построения таких структур <math>O(n \log n)</math>, таким образом, использование такой структуры не увеличивает сложность всего алгоритма.

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

<math>DBSCAN(X, \varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>p</math> in <math>X</math>:
if <math>p</math> is <math>visited</math>:
# Skipping already visited elements
continue
mark <math>p</math> as <math>visited</math>
# [Core operation] Searching for neighbors
<math>neighbours</math> = <math>\{ o \ | \ \forall o \in X: D(p, o) \le \varepsilon \}</math>
if <math>| neighbours | \ge MinPts</math>:
# Found new cluster
<math>C = C + 1</math>
add <math>p</math> to cluster <math>C</math>
# Looking for more neighbors, until none left
for <math>q \in neighbours</math>:
if <math>q</math> is not <math>visited</math>:
# If element is visited, then either it was marked as part of other cluster, or as noise
mark <math>q</math> as <math>visited</math>
# [Core operation] Searching for neighbors
<math>q\_neighbours</math> = <math>\{ o \ | \ \forall o \in X: D(q, o) \le \varepsilon \}</math>
if <math>| q\_neighbours | \ge MinPts</math>:
# We can expand neighbors with new elements from element <math>q</math>
<math>neighbours</math> = <math>neighbours \cup q\_neighbours</math>
if <math>q</math> has no cluster mark:
# If it's noise — mark as edge-element part of cluster
mark <math>q</math> as part of cluster <math>C</math>
else:
mark <math>p</math> as <math>noise</math>

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

== Информационный граф ==
Опишем граф алгоритма как аналитически, так и в виде рисунка:

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

Первой группе вершин соответствует операция Neighbours. Естественно введённые координаты области таковы:
* <math>i</math> — меняется от <math>1</math> до <math>k + f</math>, принимая все целочисленные значения, где <math>k</math> — число результирующих кластеров, <math>f</math> — число элементов помеченных, как шум
* <math>j</math> — меняется от <math>1</math> до <math>t</math>, принимая все целочисленные значения, где <math>t</math> — число вершин в кластере <math>i</math>
Второй группе вершин соответствует операция Check. Естественно введённые координаты области аналогичны предыдущей.

[[File:DBSCAN algo graph.png|thumb|center|800px|Рис. 2. Граф алгоритма DBSCAN с отображением входных данных. Element — входные данные, Neighbours — операция поиска соседей, Check — операция проверки условий, добавления вершины к кластеру и выбора новой, Out — результаты.]]

== Ресурс параллелизма алгоритма ==
Так как в данном алгоритме присутствует параллелизм по данным, ширина ярусно-параллельной формы алгоритма <math>O(w)</math>, где <math>w</math> — количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|H| \log |H|)</math>, где <math>|H|</math> — максимальное количество элементов в области среди всех частей разбиения. Именно такую сложность имеет алгоритм PDBSCAN<ref>[http://www.ece.northwestern.edu/~choudhar/Publications/ANewScalableParallelDBSCANAlgorithmUsingDisjointSetDataStructure.pdf A New Scalable Parallel DBSCAN Algorithm Using the Disjoint-Set Data Structure \ Md. Mostofa Ali Patwary, Diana Palsetia, Ankit Agrawal, Wei-keng Liao, Fredrik Manne, Alok Choudhary]</ref>, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество <math>X</math>, на котором определена функция расстояния <math>D</math>.

'''Объём входных данных''': <math>n</math> (размерность входящего множества)

'''Выходные данные''': размеченное множество точек <math>X</math>, в котором каждому элементу соответствует номер его кластера.

'''Объём выходных данных''': <math>n</math> (размерность выходящего множества)

== Свойства алгоритма ==
Вычислительная мощность алгоритма (отношение числа операций к объему входных и выходных данных) является логарифмической.
* Алгоритм может определять кластера произвольной формы;
* Параллельная реализация при равномерном разбиении сбалансирована по количеству и виду производимых операций;
* Не требуется задание числа кластеров;
* Может выделять кластеры в присутствии шума;
* Не детерминирован относительно граничных точек кластеров.

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

* [https://github.com/ContinuumIO/parallel_dbscan Параллельная реализация для Python на OpenMP/MPI]
* [https://github.com/propanoid/DBSCAN Параллельная реализация для C++ на Boost и OpenMP с использованием VP-дерева]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary Параллельная реализация для С++ на OpenMP с использованием системы непересекающихся множеств]
* [https://github.com/bwoneill/pypardis Параллельная реализация для многомерных данных для Python на SciPy и NumPy ]
* [https://github.com/mhahsler/dbscan Последовательная реализация для R на С++]

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

[[en:DBSCAN]]

Участник:EasyBreezy/Стабилизированный метод бисопряженных градиентов (BiCGSTAB)

2016-11-13T23:19:08Z

Sleo:

Основные авторы описания: Александр Новиков (1.4, 1.6, 1.7, 2.7, 3), [[Участник:EasyBreezy|Гаврилов Алексей (1.1 - 1.3, 1.5, 1.8, 1.9, 2.7, 3)]]

{{algorithm
| name = BiCGSTAB
| serial_complexity = <math> O(n^2) </math>, где <math> n </math> - размерность СЛАУ
| pf_height = <math> O(k*(6 \sqrt n + 4n + 5 \lceil \frac{n}{p} \rceil)) </math>
| pf_width = <math> 2 \sqrt n </math>
| input_data = матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> ) и вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )
| output_data = вектор решения системы <math>x \in R^N</math> ( <math>C^N</math> )
}}
== Свойства и структура алгоритма ==

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

:Стабилизированный метод бисопряженных градиентов, так же известный как BiCGSTAB (Biconjugate gradient stabilized method), был предложен голландским математиком Хенком ван дер Ворстом<ref>Henk A. vander Vorst, Iterative Krylov Methods for Large Linear Systems, Cambridge University Press 2003, 230p</ref> в 1992 году. Статья, в которой описывался метод, стала самым цитируемым научным трудом в области математики в 1990х годах.

:Метод появился, как ответ на задачу о построении способа решения систем линейных алгебраических уравнений произвольного вида. На момент появления BiCGSTAB уже существовали методы решения СЛАУ произвольного типа, в том числе и в комплексном пространстве, например метод бисопряженных градиентов. Однако существующие на тот момент методы либо обладали недостаточной скоростью сходимости, либо использовали в вычислениях тяжелые операции, такие как транспонирования матрицы, которые усложняли распараллеливание на многопроцессорных машинах.
:BiCGSTAB является итерационным методом решения систем линейных алгебраических уравнений. Мощь метода заключается в том, что его можно применять к матрицам общего вида, в том числе с комплексными коэффициентами. В процессе выполнения BiCGSTAB не использует для вычисления плохо распараллеливаемых операций, не допускает накопления погрешностей округления и нестабильного поведения невязки. Эти факторы выгодно отличают его от предшественников: метода бисопряженных градиентов и квадратичного метода сопряженных градиентов, из которого BiCGSTAB фактически и вытекает. К преимуществам так же можно добавить более высокую в общем случае скорость сходимости относительно ближайших конкурентов. Тем не менее, для некоторых видов СЛАУ BiCGSTAB может уступать более простым методам.<ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Благодаря свойствам алгоритма область применения метода весьма широка. Фактически, он используется во всех задачах, где требуется решать СЛАУ, в том числе СЛАУ большой размерности, к которым сводится большое количество численных методов, применяемых при решении задач математического моделирования.

:BiCGSTAB относится к классу так называемых проекционных методов. Основная идея методов данного класса: искать итерационным способом наилучшее приближение решения в некотором подпространстве пространства <math>R^n</math>, и чем шире подпространство, в котором ищется приближение решения, тем ближе будет приближенное решение к точному на каждой итерации. В качестве такого подпространства используются пространства Крылова, порожденные матрицей системы и невязкой первого приближения: <math>K^m (A, r^0) = span(r^0, Ar^0, A^2r^0, ..., A^{m-1} r^0).</math><ref>Горбаченко В.И, Вычислительная линейная алгебра с примерами на MATLAB. — СПб.: БХВ-Петербург, 2011. — 320 с.: ил. — (Учебное пособие)</ref>

:Изложим основную идею любого проекционного метода, заложенную в том числе и в BiCGSTAB. Для простоты выкладок и рассуждений здесь и далее будем считать, что матрица системы и ее правая часть вещественны. Без ограничения общности все дальнейшие рассуждения могут быть перенесены и на комплексный случай. Итак, пусть решается система <math>Ax=b</math> с невырожденной матрицей <math>A \in R^{n \times n}</math> и ненулевым вектором <math>b \in R^n</math>. Имеются два подпространства <math>K_n</math> и <math>L_n</math>. Требуется найти вектор <math>x \in K_n</math>, который обеспечивает решение системы, оптимальное относительно подпространства L, то есть требуется выполнение условия Петрова-Галеркина: <math>(Ax,z)=(b,z), \forall z \in L_n</math>. В данном случае вектор x называется обобщенным решением системы.

:Условие Петрова-Галеркина можно записать и через определение невязки. Пусть <math>r = b - Ax</math> - невязка, тогда условие Петрова-Галеркина перепишется в виде: <math>(b - Ax, z)=(r, z),\forall z \in L_n</math>. Это равносильно тому, что вектор невязки ортогонален пространству <math>L_n</math>.

:Пусть для СЛАУ известно некоторое приближение <math>x^0</math> точного решения <math>x^*</math>. Данное приближение требуется уточнить поправкой <math> \delta: b - Ax^0 + \delta \perp L</math>. Невязка уточненного решения имеет вид: <math>r_{new} = b - Ax^0 + \delta = r^0- A\delta</math>. Условие Петрова-Галеркина тогда можно переписать так: <math>(r_{new}, z)= r^0 - (A\delta, z) = 0, \forall z \in L</math>

:Пусть <math> dim K = dim L = m, V = (v_1, ..., v_n) \in R^{n \times m}, W = (w_1, ... w_n) \in R^{n \times m}</math>, где V и W – матрицы, столбцы которых образуют базисы пространств K и L соответственно. Пусть так же <math> \delta = Vy, z = Wq</math>, где y – коэффициенты разложения вектора поправки по базису пространства K, а q – коэффициенты разложения вектора z в пространстве L. Тогда новое приближение решения можно записать в виде: <math>x^1 = x^0 + \delta= x^0 + Vy</math>. Из условия ортогональности Петрова-Галеркина получаем, что: <math>(r - AVy, Wq) = (W^Tr^0 - AVy, q) = 0</math>. Поскольку <math>q \neq 0</math>, то получаем СЛАУ для вектора y: <math>W^TAVy = W^Tr^0</math>. Если предположить, что матрица <math>W^TAVy</math> невырождена, то вектор y однозначно определяется и равен: <math>y = W^TAV^{-1}W^Tr^0</math>. Подставляя найденные коэффициенты разложения в выражение для первого приближения получаем: <math>x^1 = x^0 + \delta = x^0 + W^TAV^{-1}W^Tr^0y</math>

:Подведем итог. Общий порядок шагов любого проекционного метода следующий:
#Выбрать пару подпространств <math>K</math> и <math>L</math>
#Найти базис V пространства K и базис W пространства <math>L</math>;
#Вычислить невязку
#Найти <math>y = W^T AV^{-1} W^T r^0</math>
#Положить <math>x = x + Vy</math>
#Если не достигнут критерий остановки итерационного процесса, то повторить алгоритм, начиная с первого шага.

:Как будет показано далее, в BiCGSTAB не требуется вычислять матрицу <math>W^T AV^{-1}</math> в явном виде.

=== Математическое описание алгоритма ===
:Рассмотрим СЛАУ с вещественными коэффициентами:
<center><math>Ax = b, A \in R^{N \times N}, b \in R^N</math></center>
<center><math></math></center>
:В основу алгоритма ложиться идея проекционного метода и использование свойства A-бисопряженности системы векторов, а именно: векторы <math>p^1, p^2, ...</math> и <math>\overline p^1, \overline p^2, ...</math> бисопряжены, если <math>(Ap^i,p^j ) = 0,</math> при <math>i \neq j</math>. Фактически, данное условие эквивалентно биортогональности относительно энергетического скалярного произведения.

:Общая концепция проекционных методов предписывает нам выбрать два подпространства. В нашем случае подпространства мы выберем два подпространства, задаваемые матрицей системы А, вектором невязки на нулевой итерации <math>r^0</math> и вектором <math>\overline r^0</math>. который выбирается из условия <math>(r^0, \overline r^0) \neq 0</math>:

<center><math>K = K^k(A, r^0), L = K^k(A, \overline r^0)</math></center>

:Метод основан на построении биортогонального базиса <math>p^0, p^1, ... p^k .. </math> пространства <math>K^k (A, r^0) </math> и вычислении поправки такой, что новое приближение на очередной итерации было бы ортогонально второму подпространству Крылова. Базисные вектора строятся до тех пор, пока не будет достигнут критерий остановки итерационного процесса, а каждое последующее приближение формируется, как сумма приближения на предыдущей итерации и найденной поправки. Критерием останова итерационного процесса является достижения невязкой значения, которое меньше некоторого наперед заданного числа <math>\epsilon</math>.

:Основной итерационный процесс задается формулами:
<center><math>x^{k + 1} = x^k + \alpha_k p_k + \omega_k s_k</math></center>
<center><math>p^{k + 1} = r^{k + 1} + \beta_k p_k - \omega_k Ap_k</math></center>
:где:
#<math>x^{k + 1}</math> - приближение на следующей итерации
#<math>x^k</math> - приближение на предыдущей итерации
#<math>p_k</math> - базисный вектор подпространства Крылова, порожденного матрице СЛАУ и невязкой
#<math>\alpha_k, \omega_k</math> - вспомогательные скаляры, определяемые для каждого шага итерации
#<math>s_k</math> - вспомогательный вектор
#<math>p^{k + 1}</math> - <math>k + 1</math>-ый базисный вектор
#<math>r^{k + 1}</math> - невязка <math>k + 1</math>-ой итерации
#<math>\beta_k</math> - вспомогательный коэффициент

:Вспомогательный вектор выражается следующим образом:
*<math>s_k = r^k - \alpha_k Ap_k</math>

:Вспомогательные коэффициенты вычисляются по формулам:
*<math>\alpha_k = \frac{(r^k, \overline r^0)}{(Ap_k, \overline r^0)}</math>
*<math>\omega_k = \frac{(As_k, s_k)}{(As_k, As_k)}</math>
*<math>\beta_k = \frac{(r^{k + 1}, \overline r^0)}{(r^k, \overline r^0}</math>

:Подведем итог и запишем итерационный процесс
:Подготовительный этап:
#Выбирается некоторое начальное приближение <math>x^0</math>
#По выбранному приближению находится невязка <math>r^0 = b - Ax^0</math>
#Из условия <math>(r^0, \overline r^0) \neq 0</math> выбирается вектор <math>\overline r^0</math>
#Положим <math>p^0 = r^0</math>
#Устанавливаем счетчик итераций: <math>n = 0</math>
:Итерационный процесс:
#Находим <math>\alpha_k</math>
#По найденному <math>\alpha_k</math> вычисляем <math>s_k</math>
#По найденному <math>s_k</math> вычисляется вспомогательный коэффициент <math>\omega_k</math>
#Находится новое приближение <math>x^{k + 1}</math>
#Вычисляется невязка <math>r^{k + 1}</math>. Если выполнено условие <math>\parallel r^{k + 1} \parallel < \epsilon</math>, то алгоритм завершается.
#Вычисляется вспомогательный коэффициент <math>\beta_k</math>
#Вычисляется новый базисный вектор: <math>p^{k + 1}</math>
#Увеличивается номер итерации: <math>n = n + 1</math>
#Переход к первому шагу итерационного процесса.

=== Вычислительное ядро алгоритма ===
:Вычислительное ядро полностью совпадает с итерационным процессом. Подготовка к итерационному процессу в ядро не включается.

=== Макроструктура алгоритма ===
На каждой итерации алгоритма используются:
# [[Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант]] x 4 раза
# [[Умножение плотной матрицы на вектор ]] х 2 раза

=== Последовательная сложность алгоритма ===
:Всего в вычислительном блоке алгоритма присутствует 20 трудоемких операций: 2 операции умножения матрицы на вектор, 6 скалярных произведений и 6 сложений/вычитаний векторов и 6 умножений вектора на число.

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

:Умножение матрицы размерности <math>n \times n</math> на вектор эквивалентно взятию еще <math>n</math> скаляров, и так как таких операций в вычислительном ядре 2, то дополнительно имеется еще <math>2n(2n - 1)</math> операций.

:Наконец, сложение или вычитание векторов требует <math>6n</math> соотвествующих операций. Столько же требует 6 произведений вектора на число.

:Итого: <math>2n(2n - 1) + 12n - 6 + 6n + 6n = 4n^2 + 22n - 6</math> операций.

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

=== Информационный граф ===
[[file:BiCGStabIterations.jpg|thumb|center|800px|<center>Информационный граф.</center>]]
На графе представлены связи между операциями, выполняющимися в первых трех итерациях метода. При выполнении большего, чем 3, количества итераций, структура каждой новой будет повторять структуру третьей. Связи между итерациями не представлены, т.к. они не важны для понимания параллельной структуры алгоритма. Серым обозначено перемножение чисел, красным - умножение числа на вектор

=== Ресурс параллелизма алгоритма ===
Основной прирост производительности параллельной версии алгоритма дает использование параллельных операций вычисления скалярного произведения, суммы векторов, а так же произведения матрицы на вектор. Каждая из операций вычисления скалярного произведения и суммы векторов, выполняемая на p процессорах, за счет метода сдваивания может ускориться до <math> \frac{p}{\log_2 p} </math> раз. Ускорение же умножения матрицы на вектор может достигать p раз.

Ширина и высота ЯПФ графа данного алгоритма напрямую зависит от конкретных реализаций макроопераций и входных данных.

Для последовательно-параллельной реализации операции взятия скалярного произведения в наиболее оптимальном случае (<math>p= \sqrt n</math>) высота будет равна <math>2 \sqrt n - 1</math>, а ширина <math>\sqrt n</math>, где n - это длина вектора решения.

Высота ЯПФ простейшего алгоритма умножения матрицы на вектор равна 2n, а ширина m, где n - это уже упомянутая длина вектора(она же ширина матрицы), а m - высота матрицы.

Высота ЯПФ операции умножения вектора на число = <math>\frac{n}{p}</math>, а ширина p.

Высота ЯПФ операции вычисления разности векторов = <math> \log_2 p </math>, а ширина p.

В конечном счете общую высоту ЯПФ одной итерации алгоритма можно оценить, как <math>6 \sqrt n-3 + 4n + 3 + 1 + 3*\lceil \frac{n}{p} \rceil + 2* \lceil \frac{n}{p} \rceil = 6 \sqrt n + 4n + 5 \lceil \frac{n}{p} \rceil + 1</math>, а ширину, как <math>2 \sqrt n</math>, если не брать в рассчет проверку критерия сходимости и упрощенности первой итерации по сравнению с остальными.

=== Входные и выходные данные алгоритма ===
:Входные данные
#Матрица <math>A \in R^{N \times N}</math> ( <math>C^{N \times N}</math> )
#Вектор правой части <math>b \in R^N</math> ( <math>C^N</math> )

:Выходные данные:
#Вектор решения СЛАУ <math>x \in R^N</math> ( <math>C^N</math> )

=== Свойства алгоритма ===
:BiCGSTAB хорошо зарекомендовал себя для решения систем линейных алгебраический уравнений, поскольку обладает некоторыми важными свойствами:
#Благодаря применению подхода Петрова-Галеркина и техники ортогонализации, он численно устойчив
#Не меняется вид матрицы в процессе решения
#Эффективен для решения систем большой размерности с разреженной матрицей, поскольку в методе самая трудоемкая операция - умножение матрицы на вектор
#Лучше подходит под распределенные системы, поскольку не содержит операции транспонирования матрицы
#Применим для решения систем с несимметричными матрицами.
#Вычислительная мощность: <math>N/4</math>

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
===== Анализ на основе теста Apex-Map =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Параллельная реализация алгоритма, предложенная MIT: [http://ab-initio.mit.edu/~meep/meep/src/bicgstab.cpp MIT BiCGSTAB]
* Параллельная реализация алгоритма в бесплатной библиотеке, поддерживающей MPI и OpenMP, HYPRE: [http://acts.nersc.gov/hypre/ Официальная страница] [https://github.com/LLNL/hypre/blob/master/src/krylov/bicgstab.c Исходный код]
* Параллельная реализация алгоритма на CUDA в условно бесплатной библиотеке [https://developer.nvidia.com/amgx/ NVIDIA AmgX]

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

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

2016-11-13T23:19:00Z

Sleo: Новая страница: «== Замечания к Стабилизированный_метод_биспоряженных_градиентов_(BiCGSTAB) == Все еще отсут…»

== Замечания к [[Стабилизированный_метод_биспоряженных_градиентов_(BiCGSTAB)]] ==

Все еще отсутствует:

1) пропущен пункт 1.5 "Схема реализации последовательного алгоритма" из-за чего сбита нумерация первой части, см [[Структура_описания_свойств_алгоритмов]]

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

2016-11-13T23:14:07Z

Sleo:

{{algorithm
| name = Построение матрицы Адамара произвольного размера
| serial_complexity = <math>O(n*(2^{n})^2))</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O((2^n)^2)</math>
| input_data = <math>1</math>
| output_data = <math>(2^n)^2</math>
}}

Работу выполнил студент 611 группы Раев Евгений.

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

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

'''Матрица Адамара''' <math>H</math> — это квадратная матрица размера ''n''×''n'', составленная из чисел 1 и −1, столбцы которой ортогональны, так что справедливо соотношение
: <math>H \cdot H^T = n \cdot E_n,</math>
где <math>E_n</math> — это единичная матрица размера ''n''. Матрицы Адамара применяются в различных областях, включая комбинаторику, численный анализ, обработку сигналов.

'''Матрица оператора Адамара''' имееет вид
:<math>\begin{align}
H = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Соответственно, существует итерационная формула нахождения матриц Адамара, через тензорное произведение матрицы оператора Адамара на матрицу Адамара меньшего порядка:
:<math>H_n = H_{1} \otimes H_{n-1}</math>, где знак <math> \otimes </math> означает тензорное произведение.

Мы будем использовать в дальнейшем нормализованную матрицу оператора Адамара, без коэффицента (для удобности вывода):
:<math>\begin{align}
H =
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Представим пример высчитывания матриц Адамара:
:<math>
H_{0} = 1,
</math>

:<math>
H_{1} = H_{1} \otimes H_{0} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes 1 = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix},
</math>

:<math>
H_{2} = H_{1} \otimes H_{1} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>

:<math>
H_{3} = H_{1} \otimes H_{2} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>

Таким образом, получаем последовательность матриц Адамамра размерностью <math>2^n</math>

<math>H^{\otimes n} = H_1 \otimes ... \otimes H_1</math>

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

Тензорное произведение довольно затратно для реализации на вычислительной технике (необходимо хранить в памяти матрицу предыдущего порядка), поэтому существует формула для определения элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum ij}</math>, где <math>i</math> и <math>j</math> - битовые представляения значений индексов, а <math>i j</math> - побитовое умножение.
То есть, знак элемента матрицы Адамара зависит от количества едининц в побитовом произведении индексов - если это число чётное - то знак положительный, если нечётное - отрицательный.

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

Вычислительное ядро расчете элементов матрицы Адамара это вычисление элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum i j}</math>
Данная операция независима для каждого элемента, соответственно именно она подлежит распараллеливанию.

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

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

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

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

1. Определение индексов находимого элемента матрицы Адамара: <math>i</math> и <math>j</math>.

2. Побитовое умножение индексов : <math>res = ij</math>.

3. Подсчет количества значащих единиц в <math>res</math>: <math>count = \sum res</math>.

4. Получение знака элемента по его четности: <math>sign = (-1)^{count}</math>.

Данному алгоритму соответствует приведенный ниже код на языке С++:
<source lang="C">
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

int get_sign(int i, int j) //Get sign Hadamard matrix's element by indices
{
int res = i & j;
int count;
for (count=0; res; res>>=1)
{
if (res & 1)
count++;
}
if (count & 1 ==1)
return -1;
else
return 1;
}

int print_HadamardMatrix(int N) //print Hadamard matrix 2^n size
{
int matr_size(pow(2,N));
for (int i = 0; i < matr_size; i++)
{
for (int j = 0; j < matr_size; j++)
{

if (get_sign(i,j)==1)
cout <<" 1 ";
else
cout <<"-1 ";
}
cout << endl;
}
cout << endl;
return 0;
}

int main(int argc, const char * argv[])
{
if(argc!=2)
{
printf("Matrix size missing\n");
return 1;
}
int N(atoi(argv[1]));
print_HadamardMatrix(N);

return 0;
}
</source>

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

Построение матрицы Адамара порядка <math>2^n</math> требует рассчета <math>(2^{n})^2</math> элементов матрицы. Это включает в себя:

1. <math>(2^{n})^2</math> побитовых умножений индексов элемента <math>i \& j</math>.

2. Операция определения значащих единиц, состоит из последовательных сдвигов и умножений на 1. В худшем случае, если мы будет рассчитывать элемент с координатам <math>(2^n-1,2^n-1)</math> будет произведено n операций сдвига (так как число <math>2^n-1 </math> кодируется n битами), и n операций умножения на 1 (для определения значащей единицы). То есть не более чем <math>2\cdot n\cdot(2^{n})^2 </math> операций на данном шаге.

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

Следовательно, общая последовательная сложность алгоритма, равна <math>(2^{n})^2 +2\cdot n\cdot(2^{n})^2 + 2^(2^{n})^2</math>, то есть <math>(2^{n})^2(2+2n)</math>, или <math>O(n*(2^{n})^2))</math>

=== Информационный граф ===
На рисунке ниже изображен информационный граф алгоритма. Всего возможно <math>(2^n)^2</math> параллельных ветвей, так как каждый элемент матрицы может считаться независимо друг от друга.
[[File:GraphHamadard.jpg|thumb|center|800px|Рисунок 1. Двухмерная модель алгоритма.]]

[[File:Raev_graph2.jpg|thumb|center|800px|Рисунок 1. Трехмерная модель алгоритма. In - взодные данные, Out - результаты, <math> \& </math> - операция умножения,<math> \sum </math> - операция подсчета значащих единиц,<math> \pm </math> - операция определения знака элемента по четности]]

1. Операция <math> \& </math> - побитовое умножение индексов.<math>ij</math>, где <math>i</math> и <math>j</math> соответствующие координаты элемента <math>h_{kl}</math>;

2. Операция <math> \sum </math> -подсчет количества значащих единиц. Состоит из последовательных сдвигов и побитового умножения с 1.

3. Операция <math> \pm </math> - определение четности количества значащих единиц. Состоит из побитового умножения количества значащих единиц с 1.

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

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

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

Ширина ярусно-параллельной формы будет равна <math>O((2^n)^2)</math> - количество рассчитываемых элементов.
Высота ярусно-параллельной формы будет равна <math>O(2+2n)=O(n)</math>
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Одно натуральное число n. Данный алгоритм на основе этого числа строит матрицу Адамара <math>H_n</math> размерности <math>2^{n}\times 2^{n}</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': <math>2^{n}\cdot 2^n</math> чисел, которые представляют собой элементы <math>H_{i,j}</math> матрицы Адамара <math>H_{n}</math> размерности <math>2^{n}\times 2^{n}</math>. Вообще говоря, в силу симметричности матрицы Адамара, можно хранить только половину от этих данных, но алгоритм в статье не предполагает такой оптимизации).

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

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

* Соотношение последовательной и параллельной сложности можно определить как отношение высоты ярусно-параллельной формы и общей последовательно сложности, то есть <math>\frac{ (2+2n)(2^n)^2 }{2+2n} = (2^n)^2 </math>. Таким образом, соотношение - экспоненциально.

* Алогритм построения матрицы Адамара не является детерминированным.

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

<math>\frac{ (2^{n})^2(2+2n) } {1+(2^{n})^2 } </math> ( то есть <math>\approx 2n</math> если <math>n -> +\infty</math>)

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

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

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

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

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

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

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

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

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

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

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

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

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

* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram]
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy]

== Литература ==
[1] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[2] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

Обсуждение участника:Евгений Раев

2016-11-13T23:13:57Z

Sleo: Новая страница: «Исправления: Нету электронных ссылок из Литературы, которую вы указали, на конкретные к…»

Исправления:

Нету электронных ссылок из Литературы, которую вы указали, на конкретные куски текста внутри вашей статьи.

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

2016-11-13T23:09:37Z

Sleo:

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

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

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

'''Объём входных данных''': 1 (натуральное число <math> n </math>).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

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

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

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

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Nikita/Построение матрицы Адамара

2016-11-13T23:08:05Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

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

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

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

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Elena777mc/Плотностный алгоритм кластеризации DBSCAN

2016-11-13T22:53:39Z

Sleo:

{{Assignment|Sleo}}
{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Elena777mc|Малахова Е.С.]] (1.2,1.4-1.8,2.7), [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]] (1.1-1.3,1.9-1.10,3)

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

== Общее описание алгоритма ==
Кластеризация – это процесс разбиения множества с <math>N</math> элементами <math>x_1, x_2, ... , x_n (x_n</math> имеет размерность <math>m</math>) на <math>K</math> кластеров, так, чтобы в каждом кластере все элементы были схожи
в каком-то смысле. <math>x_i</math> могут быть числовыми, категориальными или смешанными данными. В плотностных методах кластеры рассматриваются как регионы пространства данных с высокой плотностью объектов, которые разделены регионами с низкой плотностью объектов.

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996. – P. 226 –
231.</ref> –плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы.

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

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

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

[[File:dbscan_osn.png|thumb|right|500px| Рис. 1. Пример ядровых, граничных и шумовых точек алгоритма <ref>http://stats.stackexchange.com/questions/194734/dbscan-what-is-a-core-point</ref>]]

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных. <ref>"Xu, X. A fast parallel clustering algorithm for large spatial databases / X. Xu, M. Ester, H.-P. Kriegel // Proc. 1999 Intern. Conf. on Knowledge Discovery and Data Mining. – 1999. – Vol. 3, is. 3. – P. 263 – 290.</ref>

Для построения оценки плотности, на основе соседства точек вводятся понятия
достижимости и связности. Под <math>\varepsilon </math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon </math>, т. е.
<math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}</math>.
Тогда точка <math>y</math> достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:
:<math>
\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}
</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon </math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы.
При такой постановке задачи, под кластером понимается максимальное связное подмножество множества <math>X</math> . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждого объекта входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как требуется найти всех соседей для каждого объекта заданного множества. Основные операции, которые применяются в вычислительном ядре алгоритма: нахождение расстояние между объектами и сравнение расстояния с порогом для определения того, являются ли данные объекты <math>\varepsilon</math>-соседями.

== Макроструктура алгоритма ==
Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Это может быть R*-дерево или kd-дерево. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Сложность построения таких структур <math>O(n \log n)</math>, и использование такой структуры не увеличит сложность всего алгоритма (если сложность самого алгоритма <math>O(n \log n)</math>). Также для построения таких деревьев нужно уметь находить расстояния между объектами <math>\rho(u,v)</math>, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}</math>

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

// Основная функция, которая реализует алгоритм кластеризации
<math>DBSCAN(X, \varepsilon, MinPts)</math>
//Изначально все объекты в <math>X</math>не кластеризованы
<math>FORALL</math> objects <math>x</math> in <math>X\ DO</math>
<math>IF\ x</math> is unclassified
call function <math>expand\_cluster</math> to construct a cluster wrt. <math>\varepsilon</math> and <math>MinPts</math> containing <math>x</math>

// Вспомогательная функция, которая строит кластер на основе одной точки
<math>FUNCTION\ expand\_cluster(x,X,\varepsilon, MinPts):</math>
<math>retrive\_\varepsilon neighborhood(x, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(x) \mid < MinPts</math> //т.е. <math>x</math> - не ядровой объект
mark <math>x</math> as <math>noise</math> and <math>RETURN</math>;
<math>ELSE</math>//т.е. <math>x</math> - ядровой объект
select a new cluster-id and mark all objects in <math>N_{\varepsilon}(x)</math> with this current <math>cluster-id</math>;
push all objects from <math>N_{\varepsilon}(x)</math>\<math>(x)</math> onto the stack seeds;
<math>WHILE\ NOT</math> seeds.empty() <math>DO</math>
<math>currentObject</math> := seeds.top();
seeds.pop();
<math>retrive\_\varepsilon neighborhood(currentObject, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(currentObjects) \mid \ge MinPts</math>
select all objects in <math>N_{\varepsilon}(currentObject)</math> not yet classified or marked as <math>noise</math>,
push the unclassified objects onto seeds and mark all of these objects with current <math>cluster-id</math>;
<math>RETURN</math>

// Вспомогательная функция, для определения <math>\varepsilon</math>-соседей для объекта
<math>FUNCTION\ retrive\_\varepsilon neighborhood(x, \varepsilon)</math> //функция возвращает соседей на основе пространственной структуры данных
return <math>\{ x' \ | \ \forall x' \in X: \rho(x, x') < \varepsilon \}</math>

== Последовательная сложность алгоритма ==
Для того, чтобы алгоритм мог кластеризовать все объекты, необходимо пройти по каждому из них хотя бы один раз. Если использовать R*-дерево или kd-дерево для определения соседних объектов со сложностью <math>O(\log n)</math>, то сложность алгоритма <math>O(n \log n)</math>. Если не использовать эти структуры, то в худшем случае алгоритм будет иметь сложность <math>O(n^2)</math>, так как придется считать полную матрицу расстояний между объектами.

== Информационный граф ==
В настоящем алгоритме осуществляется параллелизм по данным. Ниже представлена общая структура данного алгоритма.
[[File:Dbscan_schema.jpg|1000px|thumb|center|Рис.1. Общая информационная структура алгоритма]]
Разбиение данных происходит с помощью пространственной структуры данных (R*-дерево, kd-дерево), которая разбивает все множество объектов <math>X</math> на <math>m</math> частей: <math>X_1,X_2,...,X_m</math>.
[[File:dbscan_clusters_partitions.png|500px|thumb|center|Рис.2. Пример разбиения объектов на части на основе пространственной структуры<ref>https://github.com/bwoneill/pypardis/blob/master/plots/median_search_split/clusters_partitions.png</ref>]]
На каждой части объектов применяется алгоритм PDBSCAN (каждая часть использует пространственную структуру данных, которая распределяется вместе с каждой частью данных). Данный алгоритм отличается от общего алгоритма DBSCAN тем, что применяется к части объектов и для каждой из этих частей определяет кандидатов на слияние. Если для ядрового объекта части <math>X_i</math> в <math>\varepsilon</math>-окрестности находится объект из другой части <math>X_j</math>, то такие объекты становятся кандидатами на слияние.

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

== Ресурс параллелизма алгоритма ==
Как видно из общей структуры графа алгоритма, ширина ярусно-параллельной формы алгоритма <math>O(m)</math>, где m - количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|X| \log |X|)</math>, где <math>\mid X \mid</math> - максимальное количество среди числа объектов в каждой части разбиения. Именно такую сложность имеет алгоритм PDBSCAN, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидова метрика между векторами из <math>{R}^n</math>.

'''Объём входных данных''': n (размерность входящего множества)

'''Выходные данные''': размеченное множество точек X, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из X сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера |X|

'''Объём выходных данных''': n (размерность выходящего множества)

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

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

''' Преимущества алгоритма '''

* алгоритм может обрабатывать большой объем данных и не зависит от порядка ввода данных;
* может определять кластера произвольной формы;
* параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>);
* не требуется задание числа кластеров;
* может выделять кластеры в присутствии «шума»и выбросов <ref>АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ
СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ/ И. А. Пестунов, Ю. Н. Синявский// Вестник Кемеровского государственного университета. – 2012. – P. 263–
299.</ref>;
* число итераций определяется заранее.

''' Недостатки алгоритма '''

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python, последовательная реализация)]
* [http://cucis.ece.northwestern.edu/projects/Clustering/download_code_dbscan.html Northwestern University (C++, параллельная реализация kd-tree)]
* [https://github.com/ContinuumIO/parallel_dbscan github/ContinuumIO (Python, параллельная реализация)]
* [https://github.com/propanoid/DBSCAN github/propanoid (C++, последовательная реализация VP tree)]
* [https://github.com/dparks1134/DBSCAN github/dparks1134 (С++, последовательная реализация)]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary Disjoint-Set Data Structure based Parallel DBSCAN (C++ параллельная реализация kd-tree)]
* [https://github.com/bwoneill/pypardis github/bwoneill (Spark/Python параллельная реализация kd-tree)]
* [https://github.com/alitouka/spark_dbscan github/alitouka (Spark/Scala параллельная реализация)]
* [https://github.com/mhahsler/dbscan CRAN (R, последовательная реализация)]

= Литература =
<references \>
<references \>[https://pdfs.semanticscholar.org/a3f8/a3948e5999def4a0819d0dbaef2ae05e1599.pdf (A Fast Parallel Clustering Algorithm for Large Spatial Databases, JOCHEN JAGER, HANS-PETER KRIEGEL)]
<references \>[http://cyberleninka.ru/article/n/algoritmy-klasterizatsii-v-zadachah-segmentatsii-sputnikovyh-izobrazheniy (АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ, Пестунов Игорь Алексеевич, Синявский Юрий Николаевич)]

[[en:Cholesky decomposition]]

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

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-11-13T22:51:36Z

Sleo:

{{Assignment|Преподаватель 1|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. [https://upload.wikimedia.org/wikipedia/commons/a/af/DBSCAN-Illustration.svg] Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

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

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике. Например, если используется расстояние Минковского порядка <math>k</math>, то расстояние между точками <math>p=(p_1,...,p_n) \in X</math> и <math>q=(q_1,...,q_n) \in X</math> вычисляется как <math>D(p, q) = (\sum_{i = 1}^{n}|p_i - q_i|^k)^{1 / k}</math>, частным случаем которой при <math>k = 2</math> является широко распространённая евклидова метрика <math>D(p, q) = \sqrt{\sum_{i = 1}^{n} (p_i - q_i)^2}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

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

<math>DBSCAN(\varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster</math> рекурсивно проходит через все точки множества <math>neighbours</math> - соседей точки <math>p</math>,
и определяет, принадлежат ли эти точки тому же кластеру <math>C</math>, тем самым расширяя этот кластер.

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours</math> возвращает для точки <math>p</math> множество всех её <math>\varepsilon</math>-соседей,
используя функцию расстояния <math>D</math>
<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполняющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

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

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-11-13T22:50:05Z

Sleo:

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. [https://upload.wikimedia.org/wikipedia/commons/a/af/DBSCAN-Illustration.svg] Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

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

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике. Например, если используется расстояние Минковского порядка <math>k</math>, то расстояние между точками <math>p=(p_1,...,p_n) \in X</math> и <math>q=(q_1,...,q_n) \in X</math> вычисляется как <math>D(p, q) = (\sum_{i = 1}^{n}|p_i - q_i|^k)^{1 / k}</math>, частным случаем которой при <math>k = 2</math> является широко распространённая евклидова метрика <math>D(p, q) = \sqrt{\sum_{i = 1}^{n} (p_i - q_i)^2}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

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

<math>DBSCAN(\varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster</math> рекурсивно проходит через все точки множества <math>neighbours</math> - соседей точки <math>p</math>,
и определяет, принадлежат ли эти точки тому же кластеру <math>C</math>, тем самым расширяя этот кластер.

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours</math> возвращает для точки <math>p</math> множество всех её <math>\varepsilon</math>-соседей,
используя функцию расстояния <math>D</math>
<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполняющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

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

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-11-13T22:48:41Z

Sleo:

{{Assignment|Sleo}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. [https://upload.wikimedia.org/wikipedia/commons/a/af/DBSCAN-Illustration.svg] Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

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

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике. Например, если используется расстояние Минковского порядка <math>k</math>, то расстояние между точками <math>p=(p_1,...,p_n) \in X</math> и <math>q=(q_1,...,q_n) \in X</math> вычисляется как <math>D(p, q) = (\sum_{i = 1}^{n}|p_i - q_i|^k)^{1 / k}</math>, частным случаем которой при <math>k = 2</math> является широко распространённая евклидова метрика <math>D(p, q) = \sqrt{\sum_{i = 1}^{n} (p_i - q_i)^2}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

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

<math>DBSCAN(\varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster</math> рекурсивно проходит через все точки множества <math>neighbours</math> - соседей точки <math>p</math>,
и определяет, принадлежат ли эти точки тому же кластеру <math>C</math>, тем самым расширяя этот кластер.

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours</math> возвращает для точки <math>p</math> множество всех её <math>\varepsilon</math>-соседей,
используя функцию расстояния <math>D</math>
<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполняющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

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

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

Обсуждение участницы:Maria rojas

2016-10-27T22:41:58Z

Sleo:

Замечание к оформлению статьи:

1. Почему написано "авторы", вы писали работы не одна? Если да, то укажите пару.

2. Почему вторая часть не соответствует структуре примера? Указанные вами два заголовка имеют номера 2.4 и 2.7, а не 2.1 2.2. Восстановите требуемую структуру.

3. Проверьте русский язык :) "При этом вычислительная мощность алгоритма, равная '''отношение''' числа операций к суммарному объему входных и выходных данных – O(\sqrt{n})." И согласование слов.

Обсуждение участницы:Maria rojas

2016-10-27T22:41:23Z

Sleo:

Замечание к оформлению статьи:

1. Почему написано "авторы", вы писали работы не одна? Если да, то укажите пару.

2. Почему часть не соответствует структуре примера? Указанные вами два заголовка имеют номера 2.4 и 2.7, а не 2.1 2.2. Восстановите требуемую структуру.

3. Проверьте русский язык :) "При этом вычислительная мощность алгоритма, равная '''отношение''' числа операций к суммарному объему входных и выходных данных – O(\sqrt{n})." И согласование слов.

Обсуждение участницы:Maria rojas

2016-10-27T22:40:26Z

Sleo: Новая страница: «Замечание к оформлению статьи: 1. Почему написано "авторы", вы писали работы не одна? Если…»

Замечание к оформлению статьи:

1. Почему написано "авторы", вы писали работы не одна? Если да, то укажите пару.

2. Почему часть не соответствует структуре примера? Указанные вами два заголовка имеют номера 2.4 и 2.7, а не 2.1 2.2. Восстановите требуемую структуру.

3. Проверьте русский язык :) "При этом вычислительная мощность алгоритма, равная '''Полужирное начертание'''отношение числа операций к суммарному объему входных и выходных данных – O(\sqrt{n})." И согласование слов.

Участник:Огнева Мария/Метод встречи посередине

2016-10-27T13:31:55Z

Sleo:

{{algorithm
| name = Метод встречи посередине
| serial_complexity = <math>O(\sqrt n\log n)</math>
| pf_height = <math>2</math>
| pf_width = <math>n</math>
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Maria rojas|М.С. Огнева]]

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

== Общее описание алгоритма ==
Криптоанализом назвают науку восстановления (дешифрования) открытого (нешифрованного) текста без доступа к ключу. Попытка криптоанализа называется атакой.

'''Методом встречи посередине''' (англ. meet-in-the-middle attack) называется класс атак на криптографические алгоритмы (алгоритмы шифрования), которые асимптотически уменьшают время полного перебора по всем ключам, но при этом увеличивают объем требуемой памяти. Впервые данный метод был предложен Уитфилдом Диффи и Мартином Хеллманом в 1977 году <ref>Diffie Whitfield, Hellman Martin E. ''Exhaustive Cryptanalysis of the NBS Data Encryption Standard.'' - Journal Computer vol.10 pp.74–84 - June 1977</ref> для блочных шифров.
=== История ===
Алгоритм шифрования [https://ru.wikipedia.org/wiki/DES DES] был принят в качестве стандарта в 1977 году. Длина ключа нового стандарта составляла 56 бит, довольно большое число по тем временам, но оставляла возможность полного перебора (<math>2^{56} </math>). В 1977 Диффи и Хеллман предложили устройство, стоимостью примерно 20 млн. долларов, которое смогло бы найти ключ DES за один день. Поэтому появилась необходимость увеличить стойкость алгоритма DES, используя технику многократного шифрования. Этот способ позволяет искусственно увеличить длину ключа, применяя несколько раз операцию шифрования с разными ключами. Так для алгоритма 2DES (двойное шифрование) длина ключа равна 112 бит, то есть полный перебор становится бессмысленной затеей.
В 1981 году Ральф Меркл и Мартин Хеллман<ref>Merkle Ralph C., Hellman Martin E. ''On the security of multiple encryption.'' - Journal Communications of the ACM, num.7 vol.24 pp.465-467 - July 1981</ref> подробно разбирают безопасность двойного шифрования и описывают метод встречи посередине, позволяющий восстановить ключ шифрования не за <math>2^{112}</math> операций шифрования, а за относительно пустяковые <math>2^{57}</math> за счет перебора не одного длинного ключа, а двух более коротких. Следующая модернизация DES - Triple DES с 168-битным ключом - требует от метода встречи посередине <math>2^{56} </math> памяти и <math>2^{112}</math> операций.

=== Особенности метода ===
# Способ шифрования: симметричный.
#:Для шифрования и расшифрования применяется один и тот же криптографический ключ.
# Условия криптоанализа: атака на основе открытого текста.
#:Известны открытый и шифрованный текст, алгоритм шифрования и дешифрования, необходимо найти ключ.
# Метод криптоанализа: универсальный.
#:С определенными вариациями метод применим ко многим шифрам.
# Применимо для любого многократного шифрования одним алгоритмом по разным ключам, а также для случая, если множество ключей криптографического алгоритма замкнуто относительно композиции (для любых ключей k' и k" найдется ключ k такой, что результат шифрования любого текста последовательно на k' и k" равен результату шифрования того же текста на k).

=== Описание метода для алгоритма двойного шифрования ===
На данной странице будет рассмотрен более простой вариант - двойное шифрование <ref>Грушо А.А., Применко Э.А., Тимонина Е.Е. ''Анализ и синтез криптоалгоритмов. Курс лекций.'' - Москва: 2000. - 110 с.</ref> (две итерации шифрования). Пусть <math>p, c</math> – открытый (plaintext) и шифрованный текст (ciphertext) соответственно. Тогда сокращение полного перебора происходит следующим образом:
#Находим множество всех шифртекстов <math>W</math>, получаемых одинарным шифрованием открытого текста p по всем возможным ключам первой итерации.
#Находим множество всех шифртекстов <math>Z</math>, получаемых одинарным дешифрованием шифрованного текста c по всем возможным ключам второй итерации.
#Если множества <math>W</math> и <math>Z</math> имеют непустое пересечение, то искомым ключом шифрования будет являться пара ключей, при помощи которых это пересечение было зашифровано из <math>p</math> и дешифровано из <math>c</math>.

== Математическое описание алгоритма ==
Пусть алгоритм шифрования описывается как <math>Enc(k, t) </math>, дешифрования <math>Dec(k, t) </math>, где <math>k</math> – ключ, <math>t</math> – текст.
Тогда получаемый двойным шифрованием по ключам <math>k_1</math> и <math>k_2</math> шифрованный текст равен: <math>c = Enc(k_2, Enc(k_1, p))</math>.
Открытый текст получается из шифрованного двойным дешифрованием: <math>p=Dec(k_1, Dec(k_2, c))</math>.

'''Исходные данные:''' тексты <math>p, c</math>.

'''Вычисляемые данные:''' ключ <math>k=(k_1, k_2)</math>, где <math>k_1 \in K_1</math>, <math>k_2 \in K_2</math>.
Предположим для упрощения, что для известной пары <math>(p, c)</math> существует единственный ключ <math>(k_1, k_2)</math>.
Составим таблицы <math>W</math> и <math>Z</math>:
*для всех <math>k^i_1 \in K_1</math>: <math>w(k^i_1) = Enc (k^i_1, p)</math>
*для всех <math>k^j_2 \in K_2</math>: <math>z(k^j_2) = Dec (k^j_2, c)</math>
Таблицы объединяются и сортируются по полученным промежуточным шифртекстам <math>z_i, w_j</math>. Пара <math>z_i = w_j</math>, которую можно найти одиночным просмотром объединенной таблицы, определяет искомый ключ <math>(k^i_1, k^j_2) </math>.

В более общем случае, может получиться не одна пара <math>z_i = w_j</math>. Тогда необходимы еще пары <math>(p, c)</math> для определения истинного ключа.

== Вычислительное ядро алгоритма ==
Основную сложность алгоритма составляет перебор ключей <math>k^i_1,k^j_2</math>, а так же сортировка полученных массивов <math>W</math> и <math>Z</math>.

== Макроструктура алгоритма ==
Метод использует в качестве составных частей следующие алгоритмы:
# Алгоритм зашифрования/расшифрования
#*В качестве основных примем алгоритмы [https://ru.wikipedia.org/wiki/Blowfish Blowfish] и [https://ru.wikipedia.org/wiki/DES DES], сложность которых пропорциональна длине ключа. В связи с тем, что длина ключа не больше 64 бит, то будем считать, что эти алгоритмы выполняются за единицу времени.
# Алгоритм сортировки
#*Будем считать, что используется быстрая сортировка или сортировка слиянием, которые в среднем работают за <math>O(n \log n)</math>.
#Алгоритм поиска
#*Совпадающие значения матриц <math>W</math> и <math>Z</math> будем искать одиночным просмотром всей таблицы.

== Схема реализации последовательного алгоритма ==
Последовательность действий метода:
# Вычислить таблицы <math>W</math> и <math>Z</math>, записывая значения в порядке вычисления и сохраняя соответствующие ключи для шифрования/дешифрования.
# Отсортировать массив <math>W \cup Z</math>.
# Найти совпадения в отсортированной таблице.

== Последовательная сложность алгоритма ==
# Сложность вычисления таблиц <math>W</math> и <math>Z</math> составит <math>O(|K_1|+|K_2|)</math> операций.
# Объединение таблиц и их сортировка будет иметь сложность: <math>O([|K_1|+|K_2|]\log[|K_1|+|K_2|])</math>.
# Поиск совпадений: <math>O(|K_1|+|K_2|)</math>.
Общая сложность всего метода равна: <math>O(|K_1|+|K_2|) + O([|K_1|+|K_2|]\log[|K_1|+|K_2|]) + O(|K_1|+|K_2|)=O([|K_1|+|K_2|]\log[|K_1|+|K_2|])</math>

Примем за <math>n</math> количество всевозможных ключей <math>k= (k_1,k_2)</math>. Если предположить, что <math>|K_1|=|K_2|</math>, то <math>|K_1|=|K_2|=\sqrt n</math>.
Тогда сложность метода составляет <math>O(\sqrt n\log n) </math>.

== Информационный граф ==
Опишем информационный граф алгоритма.

На вход подаётся открытый и шифрованный тексты. После открытый текст шифруется (Enc) по всем ключам <math>k_1</math>, а дешифрованный дешифруется (Dec) по всем ключам <math>k_2</math>. Далее полученные тексты сравниваются между собой (Cmp) и все ключи, на которых они совпали, являются выходом алгоритма.

[[file:Graph MITM.jpg|thumb|center|600px|Рисунок 1. Граф алгоритма c отображением входных и выходных данных. Plaintext — открытый текст, ciphertext — шифрованный текст, Enc — операция шифрования, Dec — операция дешифрования, Cmp — операция сравнения, Key — полученный ключ]]

== Ресурс параллелизма алгоритма ==
Как видно из информационного графа, для реализации метода в параллельном варианте потребуются выполнение следующих двух ярусов ярусно-параллельной формы (ЯПФ):
# <math>2* \sqrt{n}</math> шифрований/дешифрований
# <math>n</math> сравнений

То есть, высота ЯПФ составляет <math>2</math>, ширина – <math>n</math> (т.к. <math>n> 2* \sqrt n</math>).

== Входные и выходные данные алгоритма ==
'''Входные данные''': открытый текст <math>p</math> и шифрованный текст <math>c</math>,имеющие одинаковую длину.

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

Примем, что длина ключей <math>k_1</math> и <math>k_2</math> равна 64 битам. То есть длина текста равна 64 битам или кратна этому числу.

'''Выходные данные''': множество пар <math>(k_1,k_2)</math>, для которых нашлись совпадения.

Лишние пары могли получиться при шифровании/дешифровании одного блока текстов. Тогда для получения истинного ключа необходимо проверить все пары на блоках открытого и шифрованного текста, которые в алгоритме не использовались.

Длина искомого ключа: 128 бит.

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности для данного метода равно <math>O(\sqrt n\log n)</math>.

При этом вычислительная мощность алгоритма, равная отношение числа операций к суммарному объему входных и выходных данных – <math>O(\sqrt{n})</math>.

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

Дуги информационного графа, исходящие из вершин, соответствующих операциям шифрования/дешифрования образуют пучки мощности <math>\sqrt{n}</math>.

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

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

== Существующие реализации алгоритма ==
Реализаций метода в виде библиотек не обнаружено.
В свободном доступе существуют коды для метода встречи по середине с использованием шифрования Blowfish и хэш-таблиц на [https://gist.github.com/dchest/1062437 C], а также с использованием шифрования 2DES на [https://github.com/le1ca/class-resources/blob/master/ddes/ddes.py питоне].

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

[[Категория:Криптографические алгоритмы]]

Обсуждение участника:Mikhail Tsarev

2016-10-27T12:38:28Z

Sleo: Новая страница: «Замечания к оформлению статьи: 1. в первой строке указать вклад каждого автора в статью.…»

Замечания к оформлению статьи:

1. в первой строке указать вклад каждого автора в статью.

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

3. Литературу не использовали?

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

2016-10-27T12:36:23Z

Sleo:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(m2^{2m})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

Основные авторы описания: Хоткин Кирилл 623 гр., Царев Михаил 615 гр.

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

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

'''Матрица Адамара''' <math>H</math> порядка <math>n</math> представляет собой матрицу размера ''n''×''n'' из элементов <math>+1</math> и <math>-1</math>, такую, что: <math>H \cdot H^T = n \cdot E_n,</math>
где <math>E_n</math> — это единичная матрица размера ''n''×''n''.

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

Матрица Адамара остаётся матрицей Адамара при следующих преобразованиях:
* умножение строчки или столбца на −1;
* перестановка строчек или столбцов местами.

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

Матрица Адамара называется нормализованной, если её первая строка и столбец состоят только из единиц.

Под матрицией Адамара <math>H_m</math> подразумевается матрица порядка <math>2^m</math>

Примерами матриц Адамара различных размеров являются следующие матрицы:

<math>H_0 = (1);</math>

<math>H_1 =
\begin{pmatrix} 1 & 1
\\1 & -1
\end{pmatrix};
</math>

<math>H_2 =
\begin{pmatrix} 1 & 1 & 1 & 1
\\1 & -1 & 1 & -1
\\1 & 1 &- 1 & -1
\\1 & -1 & -1 & 1
\end{pmatrix}.
</math>

Вообще, если <math>H_m</math> матрица Адамара порядка <math>2^m</math>, то матрица
<math>H_{m+1} =
\begin{pmatrix} H_m & H_m
\\H_m & -H_m
\end{pmatrix}
</math>
является матрицей Адамара порядка <math>2^{m+1}</math>

Кроме того, матрицу Адамара порядка <math>2^m</math> можно получить по следующей формуле <math>H^{\otimes m} = H_1 \otimes ... \otimes H_1</math>, где знак <math> \otimes </math> означает тензорное произведение.

Также существует недоказанная гипотеза Адамара, которая утверждает, что существуют матрицы Адамара порядка <math>4k</math> для любого натурального <math>k</math>, однако матрица Адамара порядка <math>268</math> до сих пор не построена, как и для ряда других порядков больше <math>268</math>. Поэтому в данной работе будут рассматриваться матрицы Адамара порядка <math>2^m</math>.

=== Математическое описание алгоритма ===
Описанные ранее способы построения матрицы Адамара не являются оптимальными, поэтому вычисление матрицы Адамара порядка <math>2^m</math> будет производится поэлементно с помощью следующей формулы:

<math>
(H_m)_{ij}=(-1)^ {\sum_{k}{(i \& j)_k}},
</math>

где <math>\& - </math> побитовая операция И,

<math>(i \& j)_k - </math> <math>k</math> -ый разряд в двоичном представлении числа <math>(i \& j)</math>.

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является вычисление элементов матрицы Адамара:

<math>
(H_m)_{ij}=(-1)^ {\sum_{k}{(i \& j)_k}}.
</math>

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

<math>(-1)^ {\sum_{k}{(i \& j)_k}}.</math>

=== Схема реализации последовательного алгоритма ===
Для вычисления очередного элемента матрицы Адамара нужно выполнить следующие шаги:

1. Побитовое умножение <math>i</math> и <math>j</math>: <math>result = i \& j </math> ;

2. Нахождение числа единиц в двоичной записи числа <math>result </math>: <math> sum = \sum_{k}{(result)_k} </math>;

3. Нахождение элемента матрицы Адамара: <math>(H_m)_{ij}=(-1)^{sum}</math>.

Возможная реализация на языке C++:

<source lang="C">

int get_sign(unsigned N) {
int i;
for (i=0; N; N>>=1) { i+=N&1;}
return (i&1) ? -1 : 1;
}
void adamar(int **e, int size) {
for (unsigned int i = 0; i < size; ++i)
for (unsigned int j = 0; j < size; ++j)
e[i][j]=get_sign(i&j);
}
</source>

=== Последовательная сложность алгоритма ===
Для выполнения первого шага алгоритма для всех элементов матрицы Адамара необходимо суммарно выполнить:
* <math>2^{2m}</math> операций побитового умножения.
На втором шаге алгоритма необходимо выполнить для каждого элемента матрицы Адамара:
* от 0 до m или m логических сдвигов на один бит в зависимости от программной реализации;
* от 0 до m или m операций сложения в зависимости от программной реализации;
* от 0 до m или m операций логического умножения в зависимости от программной реализации.
На третьем шаге для всех элементов необходимо сумарно выполнить:
* <math>2^{2m}</math> операций побитового умножения;
* <math>2^{2m}</math> операций сравнения с нулем.

Взяв в расчет не самую лучшую программную реализацию второго шага, всего потребуется выполнение следующего количества операций:
* <math>(m+2)2^{2m}</math> операций логического умножения;
* <math>m\cdot2^{2m}</math> операций сложения;
* <math>m\cdot2^{2m}</math> операций логического сдвига на один бит;
* <math>2^{2m}</math> операций сравнения с нулем.
Всего <math>(3m+3)2^{2m}</math> операций.

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

На рисунке ниже изображен информационный граф алгоритма.

*<math>i\&j</math> - операция побитового умножения, где <math>i</math> и <math>j</math> соответствующие координаты элемента <math>h_{ij}</math>;
* NoO (number of ones) - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций сложения и побитового умножения;
* Sign - определение знака соответствующего элемента. Если результат предыдущего шага - чётное число, то знак положительный, иначе - отрицательный.

[[File:Hadamar matrix.png|thumb|center|1400px|Рисунок 1. Граф алгоритма построения матрицы Адамара.]]

=== Ресурс параллелизма алгоритма ===
Вычисление любого элемента можно производить независимо от других, то есть параллельно.

Высота канонической ярусно-параллельной формы равна 3.
Ширина ЯПФ равна <math>2^{2m}</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': m - размерность матрицы <math>H_m</math>.

'''Объём входных данных''': 1 (число m).

'''Выходные данные''': матрица Адамара <math>H_{m}</math> размерностью <math>2^m</math>.

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

=== Свойства алгоритма ===
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{(3m+3)2^{2m}}{1+2^{2m}}\, \approx 3m+3.</math>;
* Алгоритм построения матрицы Адамара является ''недетерминированным'', так как число операций меняется в зависимости от входных данных (числа m, которое формирует матрицу размерности 2''m'' × 2''m'');
* Данный алгоритм построения матрицы Адамара является ''несбалансированным''. Так как каждый элемент матрицы может обрабатываться независимо от других, вычисление элементов можно распределить по процессам. В случае, когда количество элементов матрицы <math>n</math> не кратно количеству процессов <math>s</math>, на некоторые процессы ложится дополнительная задача вычисления элементов матрицы в количестве <math>a=n\operatorname{mod}s</math>.

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

Учитывая, что рассматриваемый алгоритм строит симметричные матрицы Адамара, можно уменьшить количество вычисляемых элементов c <math>2^{2n}</math> до <math>\frac{2^n+2^{2n}}{2}</math> путем вычисления только диагональных и наддиагональных элементов.

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];

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

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

2016-10-27T12:18:25Z

Sleo:

Замечания к оформлению:

1. Пункт 1.7 что обозначают серые вершины на графе?

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

3. Ссылки на литературу внутри текста статьи не нашел.

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

2016-10-27T12:16:56Z

Sleo: Новая страница: «Замечания к оформлению: 1. Пункт 1.7 что обозначают серые вершины на графе? 2. в пункте 1.9 ук…»

Участник:Nikita/Построение матрицы Адамара

2016-10-27T12:13:36Z

Sleo:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

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

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

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

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

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

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

[2] Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57

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

2016-10-27T12:11:45Z

Sleo: Новая страница: «0. Отсутствует структура документа, как указано в требованиях. 1. Пункт 1.1 - это не описани…»

0. Отсутствует структура документа, как указано в требованиях.

1. Пункт 1.1 - это не описание алгоритма, это рассказ про матрицы Адамара. Надо исправить

2. Отсутствует оглавление

3. Отсутствует указания автора статьи в первой строке

4. В начале статьи должна быть таблица со следующей информацией (Последовательная сложность, Объём входных данных, Объём выходных данных, Высота ярусно-параллельной формы, Ширина ярусно-параллельной формы).

5. пункт 1.2 неполный, требуется подробное описание.

6. пункт 1.3: "Вычислительное ядро рекурсивного алгоритма состоит из \;N^2\; присвоений значений и ." Допишите до конца...

7. пункт 1.4 более подробно.

8. пункт 1.7 - не такой граф требовался, смотрите примеры. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

9. Вычислительная мощность не приведена.

10. 2.7 требуется указать больше реализаций.

11. Ссылки в самом тексте статьи указываются иначе. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

Статья требует более подробного описания КАЖДОГО пунтка

Участник:Маркова Екатерина/Построение матрицы Адамара

2016-10-27T12:05:39Z

Sleo:

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

Матрица Адамара <math>H</math> - это квадратная матрица размера <math>N\times N</math>, составленная из чисел <math>1</math> и <math>-1</math>, столбцы которой ортогональны, так что справедливо соотношение:

<math>H*H^T = N*E_N</math>,

где <math>E_n</math> - это единичная матрица размера <math>n</math>. Матрицы Адамара применяются в различных областях, включая комбинаторику, численный анализ, обработку сигналов.

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

Пусть <math>H_N</math> <math>-</math> матрица Адамара порядка <math>N</math> и <math>-H_N</math> <math>-</math> матрица с противоположными элементами. Тогда матрица <math>H_{2N}</math> получается следующим образом:
<math>H_{2N} = \begin{bmatrix}
H_N & H_N \\
H_N & -H_N
\end{bmatrix}
</math>

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

Вычислительное ядро рекурсивного алгоритма состоит из <math>\;N^2\;</math> присвоений значений и .

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

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

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

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

Сначала заполняется правый верхний блок матрицы <math>H</math>

<math>H_{ij} = H_{i(j - \frac{N}{2})}</math>, где <math>i = 1..\frac{N}{2}</math>, <math>j = \frac{N}{2}+1..N</math>;

затем левый нижний блок

<math>H_{ij} = H_{(i-\frac{N}{2})j}</math>, где <math>i = \frac{N}{2}+1..N</math>, <math>j = 1.. \frac{N}{2}</math>.

Последним заполняется нижний правый блок матрицы

<math>H_{ij} = H_{(i-\frac{N}{2})(j-\frac{N}{2})}</math>, где <math>i = \frac{N}{2}+1..N </math>, <math>j = \frac{N}{2}+1..N</math>.

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

Для заполнения матрицы <math>H</math> размера <math>N\times N</math> необходимо <math>\;N^2\;</math> присвоений значений. Из чего можно сделать вывод, что рекурсивный метод построения матрицы Адамара является алгоритмом с ''квадратичной сложностью''.

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

Зависимость данных для матрицы размерностью <math>4*4</math> можно увидеть на рис.1.

[[Файл:Pic_hadamard.png|border|500px|Some text]]

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

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

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

Входные данные: <math>N</math> - размерность матрицы.

Выходные данные: матрица размером <math>N\times N</math>.

Объем выходных данных: <math> N^2</math>.

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

Алгоритм полностью детерминирован.

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

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

Нахождение матрицы Адамара доступно в среде ''MATLAB'' и реализовано через функцию ''hadamard(n)''.[https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com]

На языке ''Java'' реализован класс ''Hadamard'' не входящий в стандарт языка. С кодом можно ознакомиться по ссылке[https://gist.github.com/guitarkitten/3937264].

== Литература ==
1. Мак-Вильямс Ф., Слоэн Н. — "Теория кодов, исправляющих ошибки" (1979)

2. Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — "Алгебраический аппарат квантовой информатики 2"

3. М. Н. Аршинов, Л. Е. Садовский — "Коды и математика" (1983)

Участник:Евгений Раев

2016-10-27T11:59:01Z

Sleo: Новая страница: «Замечания по оформлению: 1. В пункте 1.6 явно укажите общую сложность посл. алгоритма. 2. Ин…»

Замечания по оформлению:

1. В пункте 1.6 явно укажите общую сложность посл. алгоритма.

2. Информационный граф требует доработки, посмотрите пример. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

4. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

2016-10-27T11:54:16Z

Sleo:

{{algorithm
| name = Построение матрицы Адамара произвольного размера
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>(2^n)^2</math>
}}

Работу выполнил студент 611 группы Раев Евгений.

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

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

'''Матрица Адамара''' <math>H</math> — это квадратная матрица размера ''n''×''n'', составленная из чисел 1 и −1, столбцы которой ортогональны, так что справедливо соотношение
: <math>H \cdot H^T = n \cdot E_n,</math>
где <math>E_n</math> — это единичная матрица размера ''n''. Матрицы Адамара применяются в различных областях, включая комбинаторику, численный анализ, обработку сигналов.

'''Матрица оператора Адамара''' имееет вид
:<math>\begin{align}
H = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Соответственно, существует итерационная формула нахождения матриц Адамара, через тензорное произведение матрицы оператора Адамара на матрицу Адамара меньшего порядка:
:<math>H_n = H_{1} \otimes H_{n-1}</math>, где знак <math> \otimes </math> означает тензорное произведение.

Мы будем использовать в дальнейшем нормализованную матрицу оператора Адамара, без коэффицента (для удобности вывода):
:<math>\begin{align}
H =
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>

Представим пример высчитывания матриц Адамара:
:<math>
H_{0} = 1,
</math>

:<math>
H_{1} = H_{1} \otimes H_{0} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes 1 = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix},
</math>

:<math>
H_{2} = H_{1} \otimes H_{1} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>

:<math>
H_{3} = H_{1} \otimes H_{2} = \begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix} \otimes \begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix} = \begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>

Таким образом, получаем последовательность матриц Адамамра размерностью <math>2^n</math>

<math>H^{\otimes n} = H_1 \otimes ... \otimes H_1</math>

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

Тензорное произведение довольно затратно для реализации на вычислительной технике (необходимо хранить в памяти матрицу предыдущего порядка), поэтому существует формула для определения элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum ij}</math>, где <math>i</math> и <math>j</math> - битовые представляения значений индексов, а <math>i j</math> - побитовое умножение.
То есть, знак элемента матрицы Адамара зависит от количества едининц в побитовом произведении индексов - если это число чётное - то знак положительный, если нечётное - отрицательный.

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

Вычислительное ядро расчете элементов матрицы Адамара это вычисление элемента матрицы Адамара по его индексам:
:<math>H_{i,j} = (-1)^{\sum i j}</math>
Данная операция независима для каждого элемента, соответственно именно она подлежит распараллеливанию.

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

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

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

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

1. Определение индексов находимого элемента матрицы Адамара: <math>i</math> и <math>j</math>.

2. Побитовое умножение индексов : <math>res = ij</math>.

3. Подсчет количества значащих единиц в <math>res</math>: <math>count = \sum res</math>.

4. Получение знака элемента по его четности: <math>sign = (-1)^{count}</math>.

Данному алгоритму соответствует приведенный ниже код на языке С++:
<source lang="C">
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

int get_sign(int i, int j) //Get sign Hadamard matrix's element by indices
{
int res = i & j;
int count;
for (count=0; res; res>>=1)
{
if (res & 1)
count++;
}
if (count & 1 ==1)
return -1;
else
return 1;
}

int print_HadamardMatrix(int N) //print Hadamard matrix 2^n size
{
int matr_size(pow(2,N));
for (int i = 0; i < matr_size; i++)
{
for (int j = 0; j < matr_size; j++)
{

if (get_sign(i,j)==1)
cout <<" 1 ";
else
cout <<"-1 ";
}
cout << endl;
}
cout << endl;
return 0;
}

int main(int argc, const char * argv[])
{
if(argc!=2)
{
printf("Matrix size missing\n");
return 1;
}
int N(atoi(argv[1]));
print_HadamardMatrix(N);

return 0;
}
</source>

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

Построение матрицы Адамара порядка <math>N = 2^n</math> требует:

1. <math>N^2</math> побитовых умножений <math>ij</math>

2. Не детерменированное значение операций для каждого элемента на шаге вычисления значащих единиц.От 2 до <math>2N</math> операций сдвига(и, соответственно, побитовых умножений с 1) на каждый элемент.

3. <math>N^2</math> побитовых умножений количества значащих единиц с 1 для определения четности числа

=== Информационный граф ===
На рисунке ниже изображен информационный граф алгоритма. Всего возможно <math>(2^n)^2</math> параллельных ветвей, так как каждый элемент матрицы может считаться независимо друг от друга.
[[File:GraphHamadard.jpg|thumb|center|800px|Рисунок 1. Граф алгоритма.]]

1. Побитовое умножение индексов.<math>ij</math>, где <math>i</math> и <math>j</math> соответствующие координаты элемента <math>h_{kl}</math>;

2. Подсчет количества значащих единиц. Состоит из последовательных сдвигов и побитового "И" с 1.

3. Определение четности количества - побитовое "И" количества значащих единиц с 1.

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

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

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

Ширина ярусно-параллельной формы будет равна <math>O(n^2)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_{n}</math> размерностью <math>2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности является линейным.

* Алогритм построения матрицы Адамара не является детерминированным.

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

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

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

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

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

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

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

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

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

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

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

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

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

* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram]
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy]

== Литература ==
[1] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[2] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

Обсуждение участника:Бугаков Юрий

2016-10-27T11:54:00Z

Sleo: Новая страница: «Замечания к оформлению статьи: 1. в первой строке указать авторов и их вклад в статью. 2. в…»

Замечания к оформлению статьи:

1. в первой строке указать авторов и их вклад в статью.

2. в пункте 1.6 перенесите Т(n) в одну строку с концом предложения.

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

4. в пункте 2.7 убрать многоточия или заменить их на другие реализации

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

2016-10-27T11:53:52Z

Sleo:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

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

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

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

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

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

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Обсуждение участника:Руслан

2016-10-27T11:30:01Z

Sleo: Новая страница: «Замечания к оформлению статьи: 0. Укажите свои ФИО, номер группы. 1. В начале статьи должн…»

Замечания к оформлению статьи:

0. Укажите свои ФИО, номер группы.

1. В начале статьи должна быть таблица со следующей информацией (Последовательная сложность, Объём входных данных, Объём выходных данных, Высота ярусно-параллельной формы, Ширина ярусно-параллельной формы).

2. В пункте 1.7 должен быть понятный и наглядный рисунок информационного графа ('''ациклический''' граф, вершины - операции, дуги - информационные зависимости). (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

3. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

4. В пункте 1.1 не приведено ни одного свойства алгоритма.

5. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма. Описать, почему как использование специального вида деревьев улучшает алгоритм.

Участник:Руслан/Плотностный алгоритм кластеризации

2016-10-27T11:19:56Z

Sleo:

Алгоритм '''DBSCAN (Density Based Spatial Clustering of Applications with Noise)''' - плотностный алгоритм для кластеризации пространственных данных с присутствием шума), был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы. Большинство алгоритмов, производящих плоское разбиение, создают кластеры по форме близкие к сферическим, так как минимизируют расстояние до центра кластера. Авторы DBSCAN экспериментально показали, что их алгоритм способен распознать кластеры различной формы.

= ЧАСТЬ. Свойства и структура алгоритма =
Кластеризация – это процесс разбиения множества элементов на непересекающиеся кластеры, так, чтобы в каждом кластере все элементы были схожи в каком-то смысле, а объекты разных кластеров существенно отличались.

== Общее описание алгоритма ==
Идея, положенная в основу алгоритма, заключается в том, что внутри каждого кластера наблюдается типичная плотность точек (объектов), которая заметно выше, чем плотность снаружи кластера, а также плотность в областях с шумом ниже плотности любого из кластеров. Ещё точнее, что для каждой точки кластера её соседство заданного радиуса должно содержать не менее некоторого числа точек, это число точек задаётся пороговым значением. Алгоритм DBSCAN для заданных значений параметров <math>\varepsilon</math> и MinPts исследует кластер следующим образом: сначала выбирает случайную точку, являющуюся ядровой, в качестве затравки, затем помещает в кластер саму затравку и все точки, плотно-достижимые из неё.

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

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных.

Для построения оценки плотности, на основе соседства точек вводятся понятия достижимости и связности. Под <math>\varepsilon</math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math> , т. е. <math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}.</math> Тогда точка y достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:

<math>\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon</math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы. При такой постановке задачи, под кластером понимается максимальное связное подмножество множества X . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительное ядро последовательной версии зависти от поиска всех точек в <math>\varepsilon</math>-окрестности конкретной точки. Из-за поиска <math>\varepsilon</math>-соседства алгоритм имеет квадратичную вычислительную сложность <math>O(n^2)</math> (где n - количество точек). Но если задействовать K-мерное дерево, то можно снизить сложность до <math>O(\text{n log n})</math>.

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

Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Это может быть R*-дерево или k-d дерево. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Также для построения этих деревьев нужно уметь находить расстояние между объектами <math>\rho(u, v)</math> , в, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}.</math>

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

Алгоритм начинает работу с произвольной точки <math>x \in X</math> и возвращает <math>\varepsilon</math> -окрестность(строка 4). Если <math>\varepsilon</math>-окрестность содержит, как минимум minpts точек, процедура выдает новый кластер C. Алгоритм извлекает все точки в X, которые являются плотность достижима из x и добавляет их в кластер C(строки 8-17). Если в <math>\varepsilon</math>-окрестности x точек меньше, чем minpts, то x помечается как шум(строка 6). Однако, х все еще может быть добавлены в кластер, если она определится как пограничная точка во время изучения других основных точек(строки 16-17). Поиск точек в <math>\varepsilon</math>-окрестности(функция GETNEIGHBORS)известен, как запрос в диапазоне значений и получает все плотностно достижимые точки от главной точки(строки 8-17) известный как алгоритм наращивания областей. Заметим что кластер может быть определен однозначно, начиная с любой "ядровой" точки.

1: procedure DBSCAN(X, eps, minpts)
2: for each unvisited point x ∈ X do
3: mark x as visited
4: N ← GETNEIGHBORS(x, eps)
5: if |N| < minpts then
6: mark x as noise
7: else
8: C ← {x}
9: for each point x' ∈ N do
10: N ← N \ x'
11: if x' is not visited then
12: mark x' as visited
13: N' ← GETNEIGHBORS(x', eps)
14: if |N'| ≥ minpts then
15: N ← N ∪ N'
16: if x' is not yet member of any cluster then
17: C ← C ∪ {x'}

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

В общем случае алгоритм DBSCAN имеет квадратичную вычислительную сложность <math>O(n^2)</math>(где n это количество точек в X) из-за поиска <math>\varepsilon</math>-соседства. Но если использовать пространственную индексацию (например, использую k-мерное дерево[5] или R-дерево) для поиска <math>\varepsilon</math>-соседства, сложность снижается до <math>O(n log n)</math>[6].

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

На рисунке 1 представлен информационный граф алгоритма кластеризации DBSCAN. На входе у нас множество точек <math>P_i</math> и мы пробегаем по всем непосещенным точкам. Далее мы, для каждой непосещенной точки, маркируем ее как посещенную и находим всех её <math>\varepsilon</math>-соседей(на графике это узел <math>G</math>). Добавляем точку к кластеру(узел <math>C</math>). Затем, пробегаем по всем плотностно-достижимых точках(<math>P_j</math>) к нашей точке, и для каждой такой точки ищем <math>\varepsilon</math>-сосдей и добавляем их в кластер, если они ещё не принадлежат никакому кластеру.

[[file:Информационный_граф.png|thumb|center|700px|Рис.1 Граф алгоритма без отображения входных и выходных данных. <math>P_i</math> и <math>P_j</math> - точки данного множества, <math>G</math> - поиск <math>\varepsilon</math>-соседей, <math>C</math> - добавление элемента к кластеру.]]

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

Поиск <math>\varepsilon</math>-соседей требует вычисления n расстояний и выполнения n сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит O(1). Так как поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит O(n).

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

Входные данные: набор точек x, пороговое расстояние <math>\varepsilon</math>, а также минимальное количество точек, необходимых для формирования кластера, minpts.

Выход: множество кластеров С.

Если указать маленькое значение <math>\varepsilon</math>, то все точки будут шумом. Если наоборот, сделать большое значение, то кластер не будет разбит, возьмет один кластер и включит в него все точки. Также, если взять minpts слишком большое или слишком маленькое, будет либо один кластер, либо все точки шумовые. Оптимальные значения находятся опытным путем.

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

=== Преимущества алгоритма ===
* не требует указать априори количество кластеров, в отличие от K-средства

* алгоритм может разбить на произвольной формы кластеры. Даже может выявить кластер находящийся внутри другого, но не пересекающийся с ним. Из-за параметра MinPts снижается так называемый эффект однолокальности(single-link)

* алгоритм имеет понятие "шума" и устойчив к выбросам

* алгоритм требует всего два параметра и в основном нечувствительны к упорядоченности изначально данных точек

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

=== Недостатки алгоритма ===

* алгоритм не совсем детерминирован: пограничные точки, которые доступны из более чем одного кластера могут быть частью любого кластера, в зависимости от того, как происходит обработка данных. К счастью, эта ситуация не часто возникают, и мало влияет на результат кластеризации. На основных точках и точках "шума", алгоритм детерминирован. Есть DBSCAN[7] который представляет собой вариант, который рассматривает пограничные пункты как шум, и таким образом достигается полностью детерминированный результат, а также более последовательной статистической интерпретации плотности соединенных компонентов.

* качество алогоритма зависит от меры, которую мы рассматриваем в пространстве. Наиболее распространенная мера использует евклидово расстояние.

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

* алгоритм не может кластеризовать данные хорошо с большими различиями в плотности

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

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

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

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

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

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

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

== Существующие реализации алгоритма ==
[//en.wikipedia.org/wiki/ELKI ELKI] предлагает реализацию DBSCAN, а также GDBSCAN и другие варианты. Эта реализация может использовать различные структуры индексов для поквадратного выполнения и поддерживает произвольное расстояние функции и произвольные типы данных, но это можно обогнать низкоуровневой оптимизацией реализации на небольших наборах данных.

[//en.wikipedia.org/wiki/Scikit-learn Scikit-Learn] включает в себя реализацию Python для DBSCAN для произвольной метрики Минковского, который может быть ускорен с помощью KD-деревьев и шаровых деревьев, но который использует в худшем случае квадратичную память.

[//en.wikipedia.org/wiki/R_(programming_language) GNU R] содержит DBSCAN в [//cran.r-project.org/web/packages/fpc/index.html fpc] пакете с поддержкой произвольных функций расстояния через матриц. Однако он не имеет поддержки индекса (и, соответственно, имеет квадратичное время выполнения и сложность по памяти) и довольно медленно из-за интерпретации R. Более быстрая версия реализована на языке C++ с использованием KD-деревьев (только когда расстояние Евклидово ) в пакете R [//cran.r-project.org/web/packages/dbscan/index.html dbscan].

[//www.philippe-fournier-viger.com/spmf/SPMF SPMF] предлагает GPL-V3 java-реализацию алгоритма DBSCAN с поддержкой KD-дерева (только для параметра расстояние Евклида).

[//en.wikipedia.org/wiki/Weka_(machine_learning) Weka] содержит (как дополнительный пакет в последних версиях) базовую реализацию DBSCAN, которая работает за квадратичное время и линейную память.

[//en.wikipedia.org/wiki/Apache_Commons Apache Commons Мath] содержит java-реализацию алгоритма выполняющегося за квадратичное время.

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

* Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.

* Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.

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

* Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.

* A. Zhou, S. Zhou, J. Cao, Y. Fan, and Y. Hu, “Approaches for scaling DBSCAN algorithm to large spatial databases,” Journal of computer science and technology, vol. 15, no. 6, pp. 509–526, 2000.

*J. Bentley, “Multidimensional binary search trees used for associative searching,” Communications of the ACM, vol. 18, no. 9, pp. 509–517, 1975.

*Campello, R. J. G. B.; Moulavi, D.; Sander, J. (2013). Density-Based Clustering Based on Hierarchical Density Estimates. Proceedings of the 17th Pacific-Asia Conference on Knowledge Discovery in Databases, PAKDD 2013. Lecture Notes in Computer Science. p. 160.

Участник:Igor.orpanen/Плотностный алгоритм кластеризации (DBSCAN)

2016-10-27T11:19:45Z

Sleo:

{{algorithm
| name = Плотностный алгоритм кластеризации (DBSCAN)
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|S| \log S)</math>
| pf_width = <math>O(k)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}
Автор описания: [[Участник:Igor.orpanen|Орпанен И.С.]]

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

== Общее описание алгоритма ==
Задача кластеризации заключается в разделении исходной выборки данных на непересекающиеся группы, причём объекты из одной группы должны обладать сходством, которое чаще всего характеризуется функцией расстояния между объектами, например, Евклидово расстояние. Основными отличительными особенностями кластеризации являются:
* Отсутствие обучающей выборки, т.е. объектов, принадлежащих предопределённому кластеру
* Неизвестное число кластеров
* Значительная зависимость от выбранной функции расстояния между объектами

Плотностный алгоритм кластеризации DBSCAN (Density-based spatial clustering of applications with noise) является алгоритмом кластеризации, позволяющим находить кластеры произвольной формы в метрическом пространстве. Он был предложен учёными Martin Ester, Hans-Peter Kriegel, Jörg Sander и Xiaowei Xu в 1996 году.<ref name="dbscan">Ester M. et al. A density-based algorithm for discovering clusters in large spatial databases with noise //Kdd. – 1996. – Т. 96. – №. 34. – С. 226-231.</ref>

Основной идеей алгоритма DBSCAN является представление объектов кластера в виде группы точек в метрическом пространстве, являющихся вершинами одного связного графа. Причём две точки в таком графе соединеняются ребром только в том случае, если расстояние между ними в заданной метрике не превышает определённого расстояния. Если рядом с некоторым объектом нет достаточно близких соседей, то он признаётся выбросом.
== Математическое описание алгоритма ==
Входные данные: множество объектов <math>X</math>, для которых задана метрическая функция расстояния <math>\rho</math>.

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

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояния между соседними объектами,
* <math>minPts</math> - минимальное количество соседних объектов, необходимых для образования кластера.

=== Определения ===
* Объект <math>p \in X</math> называется ядровым, если в <math>\varepsilon</math>-окрестности точки <math>p</math> находятся <math>MinPts</math> объектов (включая сам объект <math>p</math>). Эти объекты называются напрямую достижимыми из <math>p</math>.
* Объект <math>q \in X</math> называется достижимым из <math>p</math>, если существует путь <math>p_1,...,p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, а каждый объект <math>p_{i+1}</math> напрямую достижим из <math>p_i</math>. Таким образом вся объекты в пути, кроме объекта <math>q</math>, должны быть ядровыми.
* Выбросами (или шумом) называются все объекты, недостижимые ни из одного другого объекта.
* Кластером является множество ядровых точек, достижимых друг из друга, а также граничные неядровые точки, которые достижимы из любой ядровой точки кластера.

=== Описание алгоритма ===
# Выбираем необработанный объект <math>p</math>.
# Отмечаем объект <math>p</math> как обработанный.
# Находим соседние объекты в <math>\varepsilon</math>-окрестности объекта <math>p</math>.
# Сравниваем количество соседних объектов с <math>MinPts</math>, определяя, является ли <math>p</math> ядровым объектом
#* Если объект <math>p</math> является ядровым, то создаём новый кластер и запускаем поиск в ширину из данного объекта по другим непосещённым объектам, находя все объекты кластера.
#* Если объект <math>p</math> не является ядровым, то отмечаем его как выброс (или шум).
# Если присутствуют необработанные объекты, то возвращаемся к шагу 1.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма представляет собой поиск соседних объектов, попадающих в <math>\varepsilon</math>-окрестность каждого объекта из множества <math>X</math>. Для достижения наибольшей производительности используется предварительные расчёты и построение специальных структур данных, позволяющих находить соседние объекты за логарифмическое время.

== Макроструктура алгоритма ==
=== Вычисление расстояния между объектами ===
Для вычисления расстояния <math>\rho</math> между двумя объектами из кластеризуемого множества используется метрика. В большинстве случаев вычисляется метрика Евклида: <math>\rho(\mathbf{p}, \mathbf{q})=\sqrt{(p_1-q_1)^2+(p_2-q_2)^2+\dots+(p_n-q_n)^2} = \sqrt{\sum_{k=1}^n (p_k-q_k)^2}</math>

В качестве альтернативного примера можно привести метрику Манхэттена, введённую Германом Минковским:
<math>\rho(\mathbf{p}, \mathbf{q}) = \sum_{i=1}^n |p_i-q_i|,</math>

=== Поиск соседних объектов в <math>\varepsilon</math>-окрестности ===
Для поиска соседних объектов может быть использован простой перебор всех известных объектов, однако последовательная сложность такого алгоритма будет равна <math>O(n^2)</math>. Для ускорения работы алгоритма обычно используются специальные структуры данных, такие как r-tree, k-d tree, ball tree, vantage-point tree и т.д. Эти структуры данных могут быть построены за время <math>O(n \log n)</math>, тем самым снизив общую временную сложность алгоритма.

== Схема реализации последовательного алгоритма ==
Схема реализации алгоритма DBScan может быть описана на псевдокоде в терминах оригинальной статьи:<ref name="dbscan" />
DBSCAN(X, Eps, MinPts) {
C = 0
for P ∈ X {
if P is visited
continue
mark P as visited
PNeighbors = regionQuery(P, Eps)
if len(PNeighbors) < MinPts
mark P as noise
else {
C = next cluster
expandCluster(P, PNeighbors, C, Eps, MinPts)
}
}
}

expandCluster(P, PNeighbors, C, Eps, MinPts) {
add P to cluster C
for each point Q ∈ PNeighbors {
if Q is not visited {
mark Q as visited
QNeighbors = regionQuery(Q, Eps)
if len(QNeighbors) >= MinPts
PNeighbors = PNeighbors ∪ QNeighbors
}
if Q is not in any cluster
add Q to cluster C
}
}

regionQuery(P, Eps)
return all points within P's Eps-neighborhood (including P)

== Последовательная сложность алгоритма ==
Последовательная сложность алгоритма DBSCAN определяется сложностью его вычислительного ядра, то есть поиска соседних объектов в <math>\varepsilon</math>-окрестности для каждого объекта из исходного множества <math>X</math>. Алгоритм посешает каждый объект из множества <math>X</math> ровно один раз, и это приводит к вызову функции regionQuery. В случае подсчёта расстояний до каждого объекта вызов функции regionQuery имеет последовательную сложность <math>O(n)</math>, а значит общая последовательная сложность равна <math>O(n^2)</math>. В случае использования вспомогательной структуры данных функция regionQuery может иметь сложность <math>O(\log n)</math>, таким образом снизив общую последовательную сложность алгоритма до <math>O(n \log n)</math>.

== Информационный граф ==
Параллельные реализации алгоритма DBSCAN всегда используют специальные пространственные структуры данных, такие как k-d tree, r-tree и vantage-point tree. Построение этих структур данных может быть распараллелено путём разделения множества объектов <math>X</math> на части <math>X_i</math>, где <math>i=\overline{1,k}</math>.

=== PDBSCAN ===
Первый рассматриваемый параллельный алгоритм PDBSCAN был предложен ещё в 1999 году.<ref name="pdbscan">Xu X., Jäger J., Kriegel H. P. A fast parallel clustering algorithm for large spatial databases //High Performance Data Mining. – Springer US, 1999. – С. 263-290.</ref>. Его основной особенностью является master-slave архитектура. Используются распределённые dR*-деревья, которые позволяют разбить метрическое пространств на области и распределить вычисления между slave-машинами. Затем в каждой из этих областей происходит поиск кластеров, а также определяется необходимость слияния с кластерами из других областей с помощью алгоритма PartDBSCAN. Затем slave-машины отправляют результаты своих вычислений на master-машину, которая сливает необходимые кластеры вместе и завершает выполнение распределённого алгоритма. Информационный граф изображён на рисунке 1.
[[file:PDBSCAN.png|thumb|center|600px|Рис.1. Информационная структура алгоритма PDBSCAN]]

=== PDSDBSCAN ===
Другой параллельный алгоритм PDSDBSCAN был предложен в 2012 году.<ref name="pdsdbscan">Patwary M. M. A. et al. A new scalable parallel DBSCAN algorithm using the disjoint-set data structure //High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. – IEEE, 2012. – С. 1-11.</ref> Его авторы отмечают недостатки master-slave архитектуры и предлагают полностью распределённый алгоритм, основанный на структуре данных из непересекаюшихся множеств, которая позволяет операцию слияния этих множеств. Это позволяет производить слияние кластеров без master-машины и значительно повысить производительность распределённого алгоритма. Информационный граф изображён на рисунке 2.
[[file:PDSDBSCAN.png|thumb|center|600px|Рис.2. Информационная структура алгоритма PDSDBSCAN]]

== Ресурс параллелизма алгоритма ==
Ширина ярусно-параллельной формы обоих алгоритмов PDBSCAN и PDSDBSCAN равна <math>O(k)</math>, где <math>k</math> - это количество частей, на которые разбивается исходный набор объектов.
Высота ярусно-параллельной платформы у обоих алгоритмов одинакова и равна <math>O(|S| \log S)</math><ref name="pdbscan" /><ref name="pdsdbscan" />, где <math>S=\max_{1 \leq i \leq k} |X_i|</math>.

== Входные и выходные данные алгоритма ==
Входные данные: множество объектов <math>X</math>, для которых задана метрическая функция расстояния <math>\rho</math>. Объём входных данных: <math>n</math>.

Выходные данные: размеченное множество объектов, где каждому объекту сопоставлен порядковый номер кластера, в который попал данный объект, либо объект отмечается как выброс (шум). Объём выходных данных: <math>n</math>.

Количество кластеров и шума в выходных данных зависят от входных данных и параметров алгоритма. Более компактное расположение объектов, меньшие значения параметра <math>MinPts</math>, большие значения параметра <math>\varepsilon</math> ведут к образования меньшего числа кластеров, вплоть до одного единственного кластера. Если варьировать данные параметры в противоположную сторону, то количество кластеров и шумовых объектов будет расти, вплоть до момента, когда все объекты будут являться шумом.

== Свойства алгоритма ==
* Алгоритм находит заранее неизвестное число кластеров произвольной формы.
* Алгоритм работает в условиях зашумлённых данных, выделяя выбросы в отдельную категорию объектов.
* Алгоритм обладает сбалансированностью вычислительного процесса относительно всех типов операций при разбиении входных данных на части примерно одинакового размера.
* Алгоритм не является детерминированным, так как в некоторых случаях граничные точки могут попасть в несколько различных кластеров, что зависит от порядка их формирования. Однако это не оказывает значительного влияния на результаты работы алгоритма. Существует вариация алгоритма DBSCAN*, которая относит все граничные точки к шуму, тем самым достигая полной детерминированности.
* Качество работы алгоритма сильно зависит от используемой метрики, а также от правильно выбранных параметров <math>MinPts</math> и <math>\varepsilon</math> для заданной предметной области. В частности для объектов в пространстве большой размерности при использовании метрики Евклида имеет место проклятие размерности.
* Алгоритм плохо работает для разнородных данных, состоящих из кластеров разной плотности, так как тогда параметры алгоритмы <math>MinPts</math> и <math>\varepsilon</math> не могут быть выбраны оптимальным образом.

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

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

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

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

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

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

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

== Существующие реализации алгоритма ==
{| class="wikitable"
|-
! Реализация
! Технологии
! Лицензия
! Посдедовательная сложность
! Структуры данных
! Метрики
! Параллельность
|-
| [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn]
| Python
| BSD 3
| <math>O(n \log n)</math>
| k-d tree, ball tree
| Любые
| style="background: #9F9;" | Есть
|-
| [https://github.com/alitouka/spark_dbscan alitouka/spark_dbscan]
| Scala, Spark
| GPLv2
| <math>O(n \log n)</math>
| r-tree
| Euclidean
| style="background: #9F9;" | Есть
|-
| [https://github.com/irvingc/dbscan-on-spark irvingc/dbscan-on-spark]
| Scala, Spark
| GPLv2
| <math>O(n \log n)</math>
| r-tree
| Euclidean
| style="background: #9F9;" | Есть
|-
| [https://github.com/propanoid/DBSCAN propanoid/DBSCAN]
| C++, Boost, OpenMP
| ABRMS
| <math>O(n \log n)</math>
| vantage-point tree
| Euclidean
| style="background: #9F9;" | Есть
|-
| [https://cran.r-project.org/web/packages/dbscan/index.html CRAN]
| R, C++
| GPLv3
| <math>O(n \log n)</math>
| k-d tree
| Euclidean
| style="background: #F99;" | Нет
|-
| [http://weka.sourceforge.net/doc.packages/optics_dbScan/weka/clusterers/DBScan.html Weka]
| Java
| GPLv3
| <math>O(n^2)</math>
| -
| Euclidean, Manhattan
| style="background: #F99;" | Нет
|-
| [https://commons.apache.org/proper/commons-math/javadocs/api-3.1/org/apache/commons/math3/stat/clustering/DBSCANClusterer.html Apache Commons]
| Java
| Apache 2.0
| <math>O(n^2)</math>
| -
| Euclidean
| style="background: #F99;" | Нет
|-
| [https://github.com/choffstein/dbscan choffstein/dbscan]
| Python
| -
| <math>O(n^2)</math>
| -
| Euclidean
| style="background: #F99;" | Нет
|}

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

Обсуждение участника:Igor.orpanen

2016-10-27T11:19:04Z

Sleo: Новая страница: «Замечания к оформлению статьи: 0. Если рисунок не ваш, то требуется указать ссылку на рес…»

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пункте 1.3 расшифруйте фразу: "построение специальных структур данных".

3. Пункт 1.5 стоит подписать комментарии к блоку псевдокода.

4. В пункте 1.7 написать пояснение к информационным графам и сделать их более подробными (особенно требуется расписать более подробно оранжевые блоки).

5. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

2016-10-26T14:43:33Z

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма.

2. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма.
2.1 Пункт 1.4 стоит расписать подробнее. Опишите термин: "пространственной структуры данных".

3. Пункт 1.5 стоит подписать комментарии к блоку псевдокода.

4. Почему в пункте 1.9 два описания входных и выходных данных?

5. В пункте 1.7 написать пояснение к информационному графу.

6. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

Обсуждение участницы:Жаннат Сагиолданова

2016-10-26T14:39:20Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма.

2. Пункт 1.6: "Если использовать специальную пространственную структуру данных" - поясните термин.

3. Пункт 1.5 стоит подписать комментарии к всем трем блокам псевдокода.

4. Почему в пункте 1.9 два описания входных и выходных данных?

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F). Информационный граф - ациклический.

6. Не указан вклад каждого из авторов статьи.

7. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

Участник:Elmon/Плотностный алгоритм кластеризации DBSCAN

2016-10-26T14:34:27Z

Sleo:

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|H| \log |H|)</math>
| pf_width = <math>O(w)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основной автор описания: [[User:Elmon|Гилевич В.В.]]

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

== Общее описание алгоритма ==
Кластеризация — это процедура, упорядочивающая элементы из некоторого множества в сравнительно однородные группы (кластеры). Элементы могут содержать числовые, категориальные или смешанные данные. Плотностные методы выделяют кластеры на основе следующей идеи: кластером считается регион с высокой плотностью объектов, которые разделены разреженными регионами (с низкой плотностью объектов)

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996.</ref> — плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения данных на кластеры произвольной формы.

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

=== Исходные данные ===
Множество <math>X</math>, на котором определена функция расстояния <math>D</math>.

=== Вычисляемые данные===
Множество пар из элемента множества <math>X</math>, и соответствующий ему номер кластера.

=== Параметры алгоритма ===
* <math>\varepsilon</math> — максимальное расстояние между соседями;
* <math>MinPts</math> — минимальное количество элементов находящихся <math>\varepsilon</math>-окрестности данного элемента для создания кластера.

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

* ''ядровой элемент'': элемент <math>p</math> является ядровым, если количество элементов в <math>\varepsilon</math>-окрестности, включая сам элемент <math>p</math> больше или равно <math>MinPts</math>;

* ''достижимость напрямую элемента <math>p</math> из элемента q'': элемент <math>p</math> считается достижимым напрямую из элемента <math>q</math>, если элемент <math>q</math> является ядровым, а элемент <math>p</math> находится в <math>\varepsilon</math>-окрестности элемента q;

* ''достижимость элемента <math>p</math> из элемента <math>q</math>'': элемент <math>p</math> достижим из элемента <math>q</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, где <math>p_{i + 1}</math> напрямую достижим из <math>p_{i}</math>;

* ''шум'': все элементы, недостижимые из какого-либо другого считаются шумом.

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

* ''связанность элемента p и элемента q'': элемент <math>p</math> считается связанным с <math>q</math>, если существует такой элемент <math>o</math>, что <math>p</math> и <math>q</math> достижимы из него.

Таким образом ''кластер'' должен удовлетворять двум условиям:
* Все элементы внутри кластера взаимно связанны;
* Если элемент связан с каким-либо элементом кластера, то он тоже является частью кластера.

[[File:DBSCAN-Illustration.svg|thumb|right|400px| Рис. 1<ref>https://en.wikipedia.org/wiki/DBSCAN Density-based spatial clustering of applications with noise (DBSCAN)</ref>. Для ''MinPts'' = 4. Красные элементы соответствуют ядровым, желтые — достижимым, синяя — шуму.]]

=== Пошаговое описание алгоритма ===

#Выбирается произвольная непосещенный элемент <math>p</math>.
#Элемент <math>p</math> помечается как посещенный.
#Проверяется, является ли элемент <math>p</math> ядровым.
#*Если элемент <math>p</math> является ядровым, то:
#**Он становится началом нового кластера или сохраняет номер кластера, который был присвоен элементу ранее;
#**Все элементы из <math>\varepsilon</math>-окрестности элемента <math>p</math> добавляются в его кластер (им присваевается номер кластера элемента <math>p</math>);
#**Процесс продолжается рекурсивно для каждого непосещенного элемента текущего кластера c шага 2.
#*Если элемент <math>p</math> не является ядровым, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является поиск элементов в <math>\varepsilon</math>-окрестности каждого элемента входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как для каждого элемента необходимо выполнить эту операцию.

== Макроструктура алгоритма ==
Алгоритм DBSCAN предполагает использование пространственной структуры данных: такие структуры позволяют найти все элементы в пределах определенного расстояния от текущего за <math>O(\log n)</math>. Сложность построения таких структур <math>O(n \log n)</math>, таким образом, использование такой структуры не увеличивает сложность всего алгоритма.

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

<math>DBSCAN(X, \varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>p</math> in <math>X</math>:
if <math>p</math> is <math>visited</math>:
continue
mark <math>p</math> as <math>visited</math>
<math>neighbours</math> = <math>\{ o \ | \ \forall o \in X: D(p, o) \le \varepsilon \}</math>
if <math>| neighbours | \ge MinPts</math>:
<math>C = C + 1</math>
add <math>p</math> to cluster <math>C</math>
for <math>q \in neighbours</math>:
if <math>q</math> is not <math>visited</math>:
mark <math>q</math> as <math>visited</math>
<math>q\_neighbours</math> = <math>\{ o \ | \ \forall o \in X: D(q, o) \le \varepsilon \}</math>
if <math>| q\_neighbours | \ge MinPts</math>:
<math>neighbours</math> = <math>neighbours \cup q\_neighbours</math>
if <math>q</math> has no cluster mark:
mark <math>q</math> as part of cluster <math>C</math>
else:
mark <math>p</math> as <math>noise</math>

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

== Информационный граф ==
Опишем граф алгоритма как аналитически, так и в виде рисунка:

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

Первой группе вершин соответствует операция Neighbours. Естественно введённые координаты области таковы:
* <math>i</math> — меняется от <math>1</math> до <math>k + f</math>, принимая все целочисленные значения, где <math>k</math> — число результирующих кластеров, <math>f</math> — число элементов помеченных, как шум
* <math>j</math> — меняется от <math>1</math> до <math>t</math>, принимая все целочисленные значения, где <math>t</math> — число вершин в кластере <math>i</math>
Второй группе вершин соответствует операция Check. Естественно введённые координаты области аналогичны предыдущей.

[[File:DBSCAN algo graph.png|thumb|center|800px| Граф алгоритма DBSCAN]]

== Ресурс параллелизма алгоритма ==
Так как в данном алгоритме присутствует параллелизм по данным, ширина ярусно-параллельной формы алгоритма <math>O(w)</math>, где <math>w</math> — количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|H| \log |H|)</math>, где <math>|H|</math> — максимальное количество элементов в области среди всех частей разбиения. Именно такую сложность имеет алгоритм PDBSCAN<ref>[http://www.ece.northwestern.edu/~choudhar/Publications/ANewScalableParallelDBSCANAlgorithmUsingDisjointSetDataStructure.pdf A New Scalable Parallel DBSCAN Algorithm Using the Disjoint-Set Data Structure \ Md. Mostofa Ali Patwary, Diana Palsetia, Ankit Agrawal, Wei-keng Liao, Fredrik Manne, Alok Choudhary]</ref>, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество <math>X</math>, на котором определена функция расстояния <math>D</math>.

'''Объём входных данных''': <math>n</math> (размерность входящего множества)

'''Выходные данные''': размеченное множество точек <math>X</math>, в котором каждому элементу соответствует номер его кластера.

'''Объём выходных данных''': <math>n</math> (размерность выходящего множества)

== Свойства алгоритма ==
* Алгоритм может определять кластера произвольной формы;
* Параллельная реализация при равномерном разбиении сбалансирована по количеству и виду производимых операций;
* Не требуется задание числа кластеров;
* Может выделять кластеры в присутствии шума;
* Не детерминирован относительно граничных точек кластеров.

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

* [https://github.com/ContinuumIO/parallel_dbscan]
* [https://github.com/propanoid/DBSCAN]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary]
* [https://github.com/bwoneill/pypardis]
* [https://github.com/mhahsler/dbscan]

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

[[en:DBSCAN]]

Участник:Elena777mc/Плотностный алгоритм кластеризации DBSCAN

2016-10-26T14:33:12Z

Sleo:

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n \log n)</math>
| pf_height = <math>O(|X| \log |X|)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

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

== Общее описание алгоритма ==
Кластеризация – это процесс разбиения множества с <math>N</math> элементами <math>x_1, x_2, ... , x_n (x_n</math> имеет размерность <math>m</math>) на <math>K</math> кластеров, так, чтобы в каждом кластере все элементы были схожи
в каком-то смысле. <math>x_i</math> могут быть числовыми, категориальными или смешанными данными. В плотностных методах кластеры рассматриваются как регионы пространства данных с высокой плотностью объектов, которые разделены регионами с низкой плотностью объектов.

Алгоритм DBSCAN (Density Based Spatial Clustering of Applications with Noise) <ref>A density-based algorithm for discovering clusters in large spatial database / M. Ester, H.-P. Kriegel,
J. Sander, X. Xu // Proc. 1996 Intern. Conf. on Knowledge Discovery and Data Mining. – 1996. – P. 226 –
231.</ref> –плотностной алгоритм для кластеризации пространственных данных с присутствием шума, был предложен Мартином Эстер, Гансом-Питером Кригель и их коллегами в 1996 году как решение проблемы разбиения (изначально пространственных) данных на кластеры произвольной формы.

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

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

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

[[File:dbscan_osn.png|thumb|right|500px| Рис. 1. Пример ядровых, граничных и шумовых точек алгоритма]]

Исходные данные: объекты, которые нужно кластеризовать, параметры <math>MinPts, \ \varepsilon</math> . Между объектами можно считать расстояния.

Вычисляемые данные: разбиение объектов по кластерам. Количество кластеров зависит от исходных данных. <ref>"Xu, X. A fast parallel clustering algorithm for large spatial databases / X. Xu, M. Ester, H.-P. Kriegel // Proc. 1999 Intern. Conf. on Knowledge Discovery and Data Mining. – 1999. – Vol. 3, is. 3. – P. 263 – 290.</ref>

Для построения оценки плотности, на основе соседства точек вводятся понятия
достижимости и связности. Под <math>\varepsilon </math> -соседями точки <math>x \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon </math>, т. е.
<math>N_\varepsilon (x) = \{y \in X | D(x, y) \le \varepsilon\}</math>.
Тогда точка <math>y</math> достижима из точки <math>x</math>, если существует последовательность точек <math>x^{(1)}=x, x^{(2)},... , x^{(p-1)}, x^{(p)}=y</math>, для которой выполнено:
:<math>
\begin{align}
x^{(i+1)} \in N_\varepsilon (x^{(i)}), i=1,... ,p-1 \\
\mid N_\varepsilon (x^{(i)}) \mid \ge MinPts, i=1,... ,p-1
\end{align}
</math>

Здесь значение <math>MinPts</math> задаётся пользователем и регулирует порог «шума». Согласно второму условию, у точек, находящихся внутри кластера, должно быть не менее <math>MinPts \ \varepsilon</math> -соседей. Такие точки называются «ядрами». Остальные точки разделяются на граничные (имеющие менее <math>MinPts \ \varepsilon </math> -cоседей, но достижимые из какого-либо «ядра») и шумовые. Две точки связны, если существует «ядро», из которого они обе достижимы.
При такой постановке задачи, под кластером понимается максимальное связное подмножество множества <math>X</math> . Точки, не попавшие в какой-либо кластер (не принадлежащие <math>\varepsilon</math> -окрестности какого-либо «ядра»), относятся к классу «шум».

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждого объекта входного множества <math>X</math>. На эту часть алгоритма приходится основное время работы алгоритма, так как требуется найти всех соседей для каждого объекта заданного множества.

== Макроструктура алгоритма ==
Алгоритм DBSCAN использует пространственную структуру данных для определения соседних объектов. Это может быть R*-дерево или kd-дерево. Такие структуры данных позволяют найти все объекты в пределах определенного расстояния от текущего объекта. Сложность построения таких структур <math>O(n \log n)</math> и использование такой структуры не увеличит сложность всего алгоритма (если сложность самого алгоритма <math>O(n \log n)</math>). Также для построения этих деревьев нужно уметь находить расстояние между объектами <math>\rho(u,v)</math>, в, это расстояние можно вводить разными способами. Например, если <math>\rho(u,v)</math> - метрика в евклидовом пространстве, <math>u=(u_1,...,u_n)</math> и <math>(v_1,...,v_n)</math>, то расстояние вычисляется следующим образом: <math>\rho(u,v)=\sqrt{(u_1-v_1)^2+(u_2-v_2)^2+...+(u_n-v_n)^2} = \sqrt{\sum_{k=1}^n(u_k-v_k)^2}</math>

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

<math>DBSCAN(X, \varepsilon, MinPts)</math>
//Изначально все объекты в <math>X</math>не кластеризованы
<math>FORALL</math> objects <math>x</math> in <math>X\ DO</math>
<math>IF\ x</math> is unclassified
call function <math>expand\_cluster</math> to construct a cluster wrt. <math>\varepsilon</math> and <math>MinPts</math> containing <math>x</math>

<math>FUNCTION\ expand\_cluster(x,X,\varepsilon, MinPts):</math>
<math>retrive\_\varepsilon neighborhood(x, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(x) \mid < MinPts</math> //т.е. <math>x</math> - не ядровой объект
mark <math>x</math> as <math>noise</math> and <math>RETURN</math>;
<math>ELSE</math>//т.е. <math>x</math> - ядровой объект
select a new cluster-id and mark all objects in <math>N_{\varepsilon}(x)</math> with this current <math>cluster-id</math>;
push all objects from <math>N_{\varepsilon}(x)</math>\<math>(x)</math> onto the stack seeds;
<math>WHILE\ NOT</math> seeds.empty() <math>DO</math>
<math>currentObject</math> := seeds.top();
seeds.pop();
<math>retrive\_\varepsilon neighborhood(currentObject, \varepsilon)</math>;
<math>IF \mid N_{\varepsilon}(currentObjects) \mid \ge MinPts</math>
select all objects in <math>N_{\varepsilon}(currentObject)</math> not yet classified or marked as <math>noise</math>,
push the unclassified objects onto seeds and mark all of these objects with current <math>cluster-id</math>;
<math>RETURN</math>

<math>FUNCTION\ retrive\_\varepsilon neighborhood(x, \varepsilon)</math> //функция возвращает соседей на основе пространственной структуры данных
return <math>\{ x' \ | \ \forall x' \in X: \rho(x, x') < \varepsilon \}</math>

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

== Информационный граф ==
В настоящем алгоритме осуществляется параллелизм по данным. Ниже представлена общая структура данного алгоритма.
[[File:dbscan_schema1.jpg|500px|thumb|center|Рис.1. Общая информационная структура алгоритма]]
Разбиение данных происходит с помощью пространственной структуры данных (R*-дерево, kd-дерево), которая разбивает все множество объектов <math>X</math> на <math>m</math> частей: <math>X_1,X_2,...,X_m</math>.
[[File:dbscan_clusters_partitions.png|500px|thumb|center|Рис.2. Пример разбиения объектов на части на основе пространственной структуры]]
Далее на каждой части объектов применяется алгоритм PDBSCAN (каждая часть использует пространственную структуру данных, которая распределяется вместе с каждой частью данных), структура которого представлена ниже.
[[File:dbscan_schema2.jpg|500px|thumb|center|Рис.3. Информационная структура алгоритма PDBSCAN]]
Данный алгоритм отличается от общего алгоритма DBSCAN тем, что применяется к части объектов и для каждой из этих частей определяет кандидатов на слияние. Если для ядрового объекта части <math>X_i</math> в <math>\varepsilon</math>-окрестности находится объект из другой части <math>X_j</math>, то такие объекты становятся кандидатами на слияние.

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

== Ресурс параллелизма алгоритма ==
Как видно из общей структуры графа алгоритма, ширина ярусно-параллельной формы алгоритма <math>O(m)</math>, где m - количество частей, на которые разбиваются все входное множество объектов <math>X</math>. Высотой ярусно-параллельной формы алгоритма является <math>O(|X| \log |X|)</math>, где <math>\mid X \mid</math> - максимальное количество среди числа объектов в каждой части разбиения. Именно такую сложность имеет алгоритм PDBSCAN, применяемый к каждой отдельной части разбиения.

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

'''Входные данные''': множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидова метрика между векторами из <math>{R}^n</math>.

'''Объём входных данных''': n (размерность входящего множества)

'''Выходные данные''': размеченное множество точек X, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из X сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера |X|

'''Объём выходных данных''': n (размерность выходящего множества)

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

''' Преимущества алгоритма '''

* алгоритм может обрабатывать большой объем данных и не зависит от порядка ввода данных;
* может определять кластера произвольной формы;
* параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>);
* не требуется задание числа кластеров;
* может выделять кластеры в присутствии «шума»и выбросов <ref>АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ
СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ/ И. А. Пестунов, Ю. Н. Синявский// Вестник Кемеровского государственного университета. – 2012. – P. 263–
299.</ref>;
* число итераций определяется заранее.

''' Недостатки алгоритма '''

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python, последовательная реализация)]
* [http://cucis.ece.northwestern.edu/projects/Clustering/download_code_dbscan.html Northwestern University (C++, параллельная реализация kd-tree)]
* [https://github.com/ContinuumIO/parallel_dbscan github/ContinuumIO (Python, параллельная реализация)]
* [https://github.com/propanoid/DBSCAN github/propanoid (C++, последовательная реализация VP tree)]
* [https://github.com/dparks1134/DBSCAN github/dparks1134 (С++, последовательная реализация)]
* [https://github.com/ahbarnett/validspike/tree/master/contrib/dbscan_patwary Disjoint-Set Data Structure based Parallel DBSCAN (C++ параллельная реализация kd-tree)]
* [https://github.com/bwoneill/pypardis github/bwoneill (Spark/Python параллельная реализация kd-tree)]
* [https://github.com/alitouka/spark_dbscan github/alitouka (Spark/Scala параллельная реализация)]
* [https://github.com/mhahsler/dbscan CRAN (R, последовательная реализация)]

= Литература =
<references \>
<references \>[https://pdfs.semanticscholar.org/a3f8/a3948e5999def4a0819d0dbaef2ae05e1599.pdf (A Fast Parallel Clustering Algorithm for Large Spatial Databases, JOCHEN JAGER, HANS-PETER KRIEGEL)]
<references \>[http://cyberleninka.ru/article/n/algoritmy-klasterizatsii-v-zadachah-segmentatsii-sputnikovyh-izobrazheniy (АЛГОРИТМЫ КЛАСТЕРИЗАЦИИ В ЗАДАЧАХ СЕГМЕНТАЦИИ СПУТНИКОВЫХ ИЗОБРАЖЕНИЙ, Пестунов Игорь Алексеевич, Синявский Юрий Николаевич)]

[[en:Cholesky decomposition]]

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

Обсуждение участницы:Жаннат Сагиолданова

2016-10-26T14:32:53Z

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. Пункт 1.3 стоит расписать подробнее. Например, привести основные операции, которые применяются выч. ядре алгоритма.

2. Пункт 1.6: "Если использовать специальную пространственную структуру данных" - поясните термин.

3. Пункт 1.5 стоит подписать комментарии к всем трем блокам псевдокода.

4. Почему в пункте 1.9 два описания входных и выходных данных?

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи.

7. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

2016-10-26T14:31:29Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

3. Пункт 1.5 стоит подписать комментарии к трем блокам псевдокода.

4. Почему в таблицу в начале выделено O(n^2), а не O(n \log n), как в пункте 1.6.

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи.

7. Не приведены:
Высота ярусно-параллельной формы -
Ширина ярусно-параллельной формы -

8. Вычислительная мощность не приведена. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

- Должны быть указаны авторы статьи (ФИО); если статья выполняется более чем одним автором, должен быть указан вклад каждого. (не указано).

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

2016-10-26T14:28:21Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

3. Пункт 1.5 стоит подписать комментарии к трем блокам псевдокода.

4. Почему в таблицу в начале выделено O(n^2), а не O(n \log n), как в пункте 1.6.

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи.

7. Не приведены:
Высота ярусно-параллельной формы -
Ширина ярусно-параллельной формы -

- Должны быть указаны авторы статьи (ФИО); если статья выполняется более чем одним автором, должен быть указан вклад каждого. (не указано).

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

2016-10-26T14:24:56Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

3. Пункт 1.5 стоит подписать комментарии к трем блокам псевдокода.

4. Почему в таблицу в начале выделено O(n^2), а не O(n \log n), как в пункте 1.6.

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи. (пункт 1.10).

7. Не приведены:
Высота ярусно-параллельной формы -
Ширина ярусно-параллельной формы -

- Должны быть указаны авторы статьи (ФИО); если статья выполняется более чем одним автором, должен быть указан вклад каждого. (не указано).

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

2016-10-26T14:21:46Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

3. Пункт 1.4 стоит подписать комментарии к трем блокам псевдокода.

4. Почему в таблицу в начале выделено O(n^2), а не O(n \log n), как в пункте 1.6.

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи. (пункт 1.10).

7. Не приведены:
Высота ярусно-параллельной формы -
Ширина ярусно-параллельной формы -

- Должны быть указаны авторы статьи (ФИО); если статья выполняется более чем одним автором, должен быть указан вклад каждого. (не указано).

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-10-26T14:20:08Z

Sleo:

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

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

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

<math>DBSCAN(X, \varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполяющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

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

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

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

2016-10-26T14:19:05Z

Sleo:

Замечания к оформлению статьи:

0. Если рисунок не ваш, то требуется указать ссылку на ресурс, откуда он был взят.

1. В пунтке 1.1 не указано ни одного свойства алгоритма. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

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

3. Пункт 1.4 стоит подписать комментарии к трем блокам псевдокода.

4. Почему в таблицу в начале выделено O(n^2), а не O(n \log n), как в пункте 1.6.

5. В постановке задачи имелось ввиду более подробное графическое описание информационного графа. (см. пример: https://algowiki-project.org/ru/%D0%A0%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%A5%D0%BE%D0%BB%D0%B5%D1%86%D0%BA%D0%BE%D0%B3%D0%BE_(%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BE%D1%80%D0%BD%D1%8F)

6. Не указан вклад каждого из авторов статьи. (пункт 1.10).

- Должны быть указаны авторы статьи (ФИО); если статья выполняется более чем одним автором, должен быть указан вклад каждого. (не указано).

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-10-26T13:42:33Z

Sleo:

{{Assignment}}

{{algorithm
| name = Плотностный алгоритм кластеризации DBSCAN
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>-</math>
| pf_width = <math>-</math>
| input_data = <math>n</math>
| output_data = <math>n</math>
}}

Авторы описания: [[Участник:Dadrik | Вашуров И.М.]], [[Участник:ramon93i7 | Шемякин Р.О.]]

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

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

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

Алгоритм DBSCAN (Density-based spatial clustering of applications with noise)<ref>Ester, Martin, et al. "A density-based algorithm for discovering clusters in large spatial databases with noise." Kdd. Vol. 96. No. 34. 1996.</ref> был предложен Мартином Эстер, Гансом-Питером Кригель и коллегами в 1996 году как решение задачи кластеризации с кластерами произвольной формы. DBSCAN является непараметрическим плотностным алгоритмом кластеризации: для заданного набора точек в некотором пространстве, алгоритм группирует те точки, которые расположены достаточно близко друг к другу (точки с большим количеством соседей), и помечает как выбросы те, что располагаются далеко от ближайших соседей.

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

== Математическое описание алгоритма ==
Вход алгоритма: множество точек <math>X</math> из <math>n</math>-мерного пространства, на котором определена функция расстояния <math>D</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера.

Параметры алгоритма:
* <math>\varepsilon</math> - максимальное расстояние между соседями;
* <math>MinPts</math> - минимальное количество соседей для создания области связности.

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

[[File:Cluster_scheme.png|thumb|right|400px| Рис. 1. Здесь ''MinPts'' = 4. Точка ''A'' и другие красные точки - ядровые и образуют единый кластер, так как достижимы друг из друга. Точки ''B'' и ''C'' не являются ядровыми, но достижимы из ''A'', а значит также принадлежат кластеру. Точка ''N'' - не достижима из других точек и является шумом.]]

Все заданные точки классифицируются на три группы:

* ''ядровые точки'': точка <math>p</math> является ядровой, если количество <math>\varepsilon</math>-соседей, включая саму точку <math>p</math>, не меньше <math>MinPts</math>. Под ''<math>\varepsilon</math>-соседями'' точки <math>p \in X</math> понимается множество точек, расстояние до которых не превышает <math>\varepsilon</math>, т.е. <math>N_\varepsilon(p) = \{ x \in X | D(p, x) \le \varepsilon \}</math>. Эти точки являются напрямую достижимыми из <math>p</math>;

* ''достижимые точки'': точка <math>q</math> достижима из <math>p</math>, если существует путь <math>p_1, \dots, p_n</math>, где <math>p_1 = p</math> и <math>p_n = q</math>, для которого выполнено:
:<math>\begin{align}
p_{i + 1} \in N_\varepsilon(p_i), i = 1, \dots, n-1 \\
| N_\varepsilon(p_{i}) | \ge MinPts, i = 1, \dots, n-1 \\
\end{align}</math>

* ''шум'' (выбросы): все точки, недостижимые из какой-либо другой точки считаются шумом (выбросом).

Так, если <math>p</math> - ядровая точка, то она образует кластер вместе со всеми точками, достижимыми из неё. Каждый кластер содержит по крайней мере одну ядровую точку; неядровые точки могут быть частью кластера, образуя при этом его "границу", так как они не могут быть использованы для достижения других точек.

Достижимость не является симметричным отношением, так как по определению никакая точка не может быть достижима из неядровой точки, независимо от расстояния. Поэтому в DBSCAN применяется следующий термин ''связности'': две точки <math>p</math> и <math>q</math> связанны, если существует такая точка <math>o</math>, что <math>p</math> и <math>q</math> достижимы из <math>o</math>. Такое отношение связности симметрично.

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

=== Шаги алгоритма ===

#Выбирается произвольная непосещенная точка <math>p</math>.
#Точка <math>p</math> помечается как посещенная.
#У точки <math>p</math> определяется множество её <math>\varepsilon</math>-соседей - <math>N_\varepsilon(p)</math>.
#*Если точка <math>p</math> оказалась ядровой - <math>| N_\varepsilon(p) | \ \ge MinPts</math>, то:
#**она становится началом нового кластера или сохраняет номер кластера, который был ей присвоен ранее;
#**все точки из <math>N_\varepsilon(p)</math> добавляются в её кластер;
#**процесс продолжается рекурсивно для каждой новой добавленной непосещенной точки <math>p' \in N_\varepsilon(p)</math> c шага 2 (в качестве новой <math>p</math>).
#*Если точка <math>p</math> оказалась не ядровой, то <math>p</math> объявляется шумом. Алгоритм продолжается с шага 4.
#Если остались непосещенные точки, то алгоритм продолжается с шага 1.

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

Вычислительным ядром алгоритма является нахождение <math>\varepsilon</math>-соседей каждой точки входного множества <math>X</math>.

Для решения этой задачи требуется найти расстояния между любыми двумя точками множества <math>X</math> по заданной метрике.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют вызовы функции <math>request\_neighbours</math> получения <math>\varepsilon</math>-соседей и нахождение расстояний между точками множества <math>X</math>.

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

<math>DBSCAN(X, \varepsilon, MinPts)</math>
<math>C = 0</math>
for <math>\forall p \in X</math>
if <math>p</math> is visited then
continue
mark <math>p</math> as visited
<math>neighbours</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours | < MinPts</math> then
mark <math>p</math> as <math>NOISE</math>
else
<math>C = next\_cluster</math>
<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>

<math>expand\_cluster(p, neighbours, C, \varepsilon, MinPts)</math>
add <math>p</math> to cluster <math>C</math>
for <math>\forall p' \in neighbours</math>
if <math>p'</math> is not visited
mark <math>p'</math> as visited
<math>neighbours'</math> = <math>request\_neighbours(p, \varepsilon)</math>
if <math>| neighbours' | \ \ge MinPts</math>
<math>neighbours</math> = <math>neighbours \cup neighbours'</math>
if <math>p'</math> is not yet member of any cluster
add <math>p'</math> to cluster <math>C</math>

<math>request\_neighbours(p, \varepsilon)</math>
return <math>\{ p' \ | \ \forall p' \in X: D(p, p') < \varepsilon \}</math>

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

DBSCAN проходит через каждую точку входного множества, возможно, по несколько раз. Временная сложность зависит в большей степени от вызова функции <math>request\_neighbours</math> (нахождение <math>\varepsilon</math>-соседей для заданной точки). Эта функция вызывается ровно один раз для каждой точки множества <math>X</math>.

Если использовать индексированную структуру данных (например, R-деревья), выполяющую операцию <math>request\_neighbours</math> за <math>O(\log n)</math>, то суммарная сложность алгоритма в среднем составит <math>O(n \log n)</math>, с учётом хорошо подобранного параметра <math>\varepsilon</math>, такого что в среднем <math>request\_neighbours</math> возвращает <math>O(\log n)</math> точек. Без использования ускоряющих структур или на вырожденных данных (таких, что все точки находятся на расстоянии меньшем, чем <math>\varepsilon</math> друг от друга) сложность по времени в худшем случае будет <math>O(n^2)</math>.

Расстояния между точками можно вычислить заранее за <math>O(\frac {n(n - 1)}{2})</math>, например в виде матрицы расстояний, но это потребует <math>O(n^2)</math> памяти. Иначе, расстояния будут вычисляться при каждом запуске функции <math>request\_neighbours</math> за <math>O(n)</math> и потребуют <math>O(n)</math> памяти. Итоговая сложность вычисления расстояний в таком случае составляет <math>O(n^2)</math>. Сложность рассчета расстояний зависит от природы объектов из <math>X</math> и заданной метрики <math>D</math>. Например, если <math>X\subset\mathbb{R}^m</math>, то сложность равна <math>O(m)</math>, но оценка может быть улучшена при использовании векторных операций.

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

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

[[File:Dbscan abstract.png |thumb|right|320px| Рис. 2. Внешний цикл алгоритма.]]

На рис. 2 изображен информационный граф внешнего цикла алгоритма, который соответствует коду основной функции <math>DBSCAN</math>:
*Макрооперация ''Init'' заключается в получении множества <math>X</math> и инициирования вспомогательных структур.
*Макрооперация ''Choose'' производит выбор непосещенной точки из <math>X</math>.
*Макрооперация ''Build cluster'' строит кластер, если точка ядровая, или объявляет ее шумом.

Переход от ''Build cluster'' к ''Choose'' заключает в себе зависимость данных о принадлежности некоторых точек к текущему кластеру или шуму и об их посещенности.

[[File:Expand cluster 2.png |thumb|right|600px| Рис. 3. Расширение кластера.]]

На рис. 3 изображен информационный граф алгоритма расширения кластера из начальной точки кластера:
*Макрооперация ''Init'' заключается в создании кластера из его начальной вершины.
*Макрооперация ''Nε'' вычисляет множество <math>\varepsilon</math>-соседей.
*Желтым цветом обозначены узлы, в которых точки из <math>\varepsilon</math>-соседей классифицируются на ядровые, граничные точки и шум. В рамках операции для конкретного соседа вычисляется множество его <math>\varepsilon</math>-соседей.
*Макрооперации ''Ñε'', ''Ňε'', ... производят объединение входных множеств.
*Макрооперация ''Ø'' выполняется тогда, когда объединение входных множеств является пустым.

[[File:N eps 3.png |thumb|right|320px| Рис. 4. Подсчет <math>\varepsilon</math>-соседей.]]

На рис. 4 изображен информационный граф алгоритма вычисления множества <math>\varepsilon</math>-соседей:
*Операция ''D'' - вычисление расстояния между точками.
*Операция ''ε'' - сравнение расстояния с ε.
*Операция ''U'' - объединение результатов.

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

Поиск <math>\varepsilon</math>-соседей требует вычисления <math>n</math> расстояний (функция <math>D</math>) и выполнения <math>n</math> сравнений с <math>\varepsilon</math>. Эти операции для каждой пары точек независимы и могут быть выполнены параллельно. Таким образом, при наличии неограниченного числа процессоров сложность поиска составит <math>O(1)</math>. Т.к. поиск выполняется для каждой точки ровно один раз, параллельная сложность всего алгоритма составит <math>O(n)</math>.

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

Вход алгоритма: множество точек X из n-мерного пространства, на котором определена функция расстояния D. В наиболее распространенном случае пространственной кластеризации используется Евлидово расстояние между векторами из <math>\mathbb{R}^n</math>.

Выход алгоритма: размеченное множество точек <math>X</math>, в котором каждой точке соответствует номер ее кластера. Обычно каждой точке из <math>X</math> сопоставляется ее номер, а на выходе алгоритм дает отображение номеров точек в номера соответствующих им кластеров, например в виде вектора размера <math>|X|</math>.

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

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

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

=== Преимущества алгоритма ===

# не требует указывать число кластеров;
# может определять кластера произвольной формы;
# может определять шум и устойчив к выбросам;
# требует всего два параметра и по в большинстве случаев не чувствителен к порядку заданных точек;
# параллельная реализация сбалансирована по количеству и виду производимых операций (вычисление расстояния, сравнение с <math>\varepsilon</math>).

=== Недостатки алгоритма ===

# не детерминирован: граничные точки, достижимые из более, чем одного кластера, могут быть частью любого из них в зависимости от порядка обрабатываемых данных. Однако такая ситуация возникает редко, а относительно ядровых точек и шума DBSCAN детерминирован. Впрочем, от недетерминизма можно избавиться, если считать все граничные точки шумом (алгоритм DBSCAN*);
# качество алгоритма зависит от используемой функции расстояния <math>D</math>. Наиболее часто используемое Евклидово расстояние в многомерных множествах может оказаться практически бесполезным из-за так называемого "проклятия размерности", значительно затрудняя нахождение подходящего значения <math>\varepsilon</math>;
# не может выделять кластеры, имеющие разную плотность, так как параметры алгоритма не могут быть выбранны отдельно для каждого кластера.

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

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

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

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

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

!!! ЭКСПЕРИМЕНТЫ ДО 15 НОЯБРЯ !!!

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

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

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

* [http://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html Scikit learn (Python)]
* [https://cran.r-project.org/web/packages/dbscan/dbscan.pdf R-project] ([https://github.com/mhahsler/dbscan github])
* [https://www.mathworks.com/matlabcentral/fileexchange/52905-dbscan-clustering-algorithm Matlab]
* P-DBSCAN (Parallel DBSCAN)<ref>Chen, Min, Xuedong Gao, and HuiFei Li. "Parallel DBSCAN with priority r-tree." Information Management and Engineering (ICIME), 2010 The 2nd IEEE International Conference on. IEEE, 2010.</ref>
* Parallel DBSCAN with MPI<ref>Savvas, Ilias K., and Dimitrios Tselios. "Parallelizing DBSCaN Algorithm Using MPI." Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), 2016 IEEE 25th International Conference on. IEEE, 2016.</ref>
* PDSDBSCAN (Parallel Disjoint-Set DBSCAN)<ref>Patwary, Md Mostofa Ali, et al. "A new scalable parallel DBSCAN algorithm using the disjoint-set data structure." High Performance Computing, Networking, Storage and Analysis (SC), 2012 International Conference for. IEEE, 2012.</ref>

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

<references />

Участник:Dadrik/Плотностный алгоритм кластеризации

2016-10-26T13:42:23Z

Sleo: