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

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-29T19:56:12Z

Kravtsovkirill:

{{Assignment}}

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета. Алгоритм был реализован с помощью языка Fortran 90.

Реализация тестировалась со следующими параметрами:

* число процессоров [1 : 128];
* размер входного слоя сети, а также слоя Кохонена (были установлены равными друг другу) [1000 : 4000].

[[Файл:Plot_s2.svg|thumb|600px|center| На рисунке представлен график зависимости времени выполнения от числа процессоров и размерности входных данных]]

[[Файл:Plot_s3.svg|thumb|600px|center| Производительность в зависимости от числа процессоров и размерности входных данных]]

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

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

program Kohonen
implicit none
include 'mpif.h'
integer rank,ierr,size,sizeBlock
integer n,perProc,i,j,k,jmin,jAbsWin
integer iterNum,IOS
real learning_rate
real dist,prom,minDist
real, allocatable :: W(:,:),sample(:,:),maswin(:,:)
real, allocatable :: buf(:,:),win(:)
double precision start,finish
character str

iterNum = 1000
n=1000

learning_rate = 1.0

allocate(W(n,n))
allocate(sample(iterNum,n))
allocate(win(2))

call randMatr(sample,iterNum,n,.FALSE.)
call randMatr(W,n,n,.True.)

call MPI_INIT(IERR)
call MPI_COMM_SIZE(MPI_COMM_WORLD,SIZE,IERR)
call MPI_COMM_RANK(MPI_COMM_WORLD,RANK,IERR)

perProc = n/size
allocate(buf(n,perProc))
allocate(maswin(2,size))
sizeBlock = perProc * n

if (rank .eq. 0) then
start = MPI_WTIME(IERR)
end if

do i=1,IterNum,1
call obnul(buf,n,perProc)
call MPI_SCATTER(W,sizeBlock,MPI_REAL,buf,sizeBlock,MPI_REAL,0,MPI_COMM_WORLD,IERR)

dist = euclDist(sample(i,1:n),buf(1:n,1),n)
do j=1,perProc,1
prom = euclDist(sample(i,1:n),buf(1:n,j),n)
if (prom .le. dist) then
dist = prom
jmin = j + rank*perProc
end if
enddo
win(1) = jmin
win(2) = dist

call MPI_BARRIER(MPI_COMM_WORLD,IERR)

call MPI_GATHER(win,2,MPI_REAL,maswin,2,MPI_REAL,0,MPI_COMM_WORLD,IERR)

if (rank .eq. 0) then
minDist = maswin(2,1)
jAbsWin = maswin(1,1)
do j=2,size,1
if (mindist .ge. maswin(2,j)) then
minDist = maswin(2,j)
jAbsWin = maswin(1,j)
endif
enddo
call modW(W,n,learning_rate,i,jAbsWin)
end if
enddo

if (rank .eq. 0) then
finish = MPI_WTIME(IERR)
open(1,file="Rezult.txt",iostat=IOS)
do while (.NOT. eof(1))
read(1,*) str
enddo
write (1,*) 'Neurons: ',n,'Processes: ',size,'Time: ',finish-start
close(1)
end if

call MPI_FINALIZE(IERR)

!call printm(W,n,n)

deallocate(W,sample,win,maswin,buf)

contains

subroutine printm(W,a,b)
integer a,b,i,j
real W(n,n)

do j=1,b,1
write(*,*)(W(i,j), i=1,a)
enddo
end subroutine printm

subroutine obnul(W,a,b)
integer a,b
integer i,j
real W(a,b)

do j=1,b,1
do i=1,a,1
W(i,j) = 0.0
enddo
enddo
end subroutine obnul

real function euclDist(a,b,n)
integer n,i
real a(n),b(n),res

res = 0
do i = 1,n,1
res = res + (a(i) - b(i)) * (a(i) - b(i))
enddo

euclDist = sqrt(res)
end function euclDist

subroutine modW(W,n,learning_rate,iter,jAbsWin)
integer n,iter,JAbsWin
real learning_rate,W(n,n)
integer i,j

do j=1,n,1
if (j .ne. jAbsWin) then
do i=1,n,1
W(i,j) = W(i,j) + learning_rate/sqrt(iter+1.0)*(W(i,jAbsWin)-W(i,j))
enddo
end if
enddo
end subroutine modW

subroutine randMatr(matr,a,b,small)
integer a,b
logical small
integer i,j
real matr(a,b),x

do j=1,b,1
do i=1,a,1
call random_seed
call random_number(x)
x = x * 10 - x * 8
if (small) then
x = x / 40
end if
matr(i,j) = x
enddo
enddo
end subroutine randMatr
end program Kohonen

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-29T19:55:18Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета. Алгоритм был реализован с помощью языка Fortran 90.

Реализация тестировалась со следующими параметрами:

* число процессоров [1 : 128];
* размер входного слоя сети, а также слоя Кохонена (были установлены равными друг другу) [1000 : 4000].

[[Файл:Plot_s2.svg|thumb|600px|center| На рисунке представлен график зависимости времени выполнения от числа процессоров и размерности входных данных]]

[[Файл:Plot_s3.svg|thumb|600px|center| Производительность в зависимости от числа процессоров и размерности входных данных]]

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

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

program Kohonen
implicit none
include 'mpif.h'
integer rank,ierr,size,sizeBlock
integer n,perProc,i,j,k,jmin,jAbsWin
integer iterNum,IOS
real learning_rate
real dist,prom,minDist
real, allocatable :: W(:,:),sample(:,:),maswin(:,:)
real, allocatable :: buf(:,:),win(:)
double precision start,finish
character str

iterNum = 1000
n=1000

learning_rate = 1.0

allocate(W(n,n))
allocate(sample(iterNum,n))
allocate(win(2))

call randMatr(sample,iterNum,n,.FALSE.)
call randMatr(W,n,n,.True.)

call MPI_INIT(IERR)
call MPI_COMM_SIZE(MPI_COMM_WORLD,SIZE,IERR)
call MPI_COMM_RANK(MPI_COMM_WORLD,RANK,IERR)

perProc = n/size
allocate(buf(n,perProc))
allocate(maswin(2,size))
sizeBlock = perProc * n

if (rank .eq. 0) then
start = MPI_WTIME(IERR)
end if

do i=1,IterNum,1
call obnul(buf,n,perProc)
call MPI_SCATTER(W,sizeBlock,MPI_REAL,buf,sizeBlock,MPI_REAL,0,MPI_COMM_WORLD,IERR)

dist = euclDist(sample(i,1:n),buf(1:n,1),n)
do j=1,perProc,1
prom = euclDist(sample(i,1:n),buf(1:n,j),n)
if (prom .le. dist) then
dist = prom
jmin = j + rank*perProc
end if
enddo
win(1) = jmin
win(2) = dist

call MPI_BARRIER(MPI_COMM_WORLD,IERR)

call MPI_GATHER(win,2,MPI_REAL,maswin,2,MPI_REAL,0,MPI_COMM_WORLD,IERR)

if (rank .eq. 0) then
minDist = maswin(2,1)
jAbsWin = maswin(1,1)
do j=2,size,1
if (mindist .ge. maswin(2,j)) then
minDist = maswin(2,j)
jAbsWin = maswin(1,j)
endif
enddo
call modW(W,n,learning_rate,i,jAbsWin)
end if
enddo

if (rank .eq. 0) then
finish = MPI_WTIME(IERR)
open(1,file="Rezult.txt",iostat=IOS)
do while (.NOT. eof(1))
read(1,*) str
enddo
write (1,*) 'Neurons: ',n,'Processes: ',size,'Time: ',finish-start
close(1)
end if

call MPI_FINALIZE(IERR)

!call printm(W,n,n)

deallocate(W,sample,win,maswin,buf)

contains

subroutine printm(W,a,b)
integer a,b,i,j
real W(n,n)

do j=1,b,1
write(*,*)(W(i,j), i=1,a)
enddo
end subroutine printm

subroutine obnul(W,a,b)
integer a,b
integer i,j
real W(a,b)

do j=1,b,1
do i=1,a,1
W(i,j) = 0.0
enddo
enddo
end subroutine obnul

real function euclDist(a,b,n)
integer n,i
real a(n),b(n),res

res = 0
do i = 1,n,1
res = res + (a(i) - b(i)) * (a(i) - b(i))
enddo

euclDist = sqrt(res)
end function euclDist

subroutine modW(W,n,learning_rate,iter,jAbsWin)
integer n,iter,JAbsWin
real learning_rate,W(n,n)
integer i,j

do j=1,n,1
if (j .ne. jAbsWin) then
do i=1,n,1
W(i,j) = W(i,j) + learning_rate/sqrt(iter+1.0)*(W(i,jAbsWin)-W(i,j))
enddo
end if
enddo
end subroutine modW

subroutine randMatr(matr,a,b,small)
integer a,b
logical small
integer i,j
real matr(a,b),x

do j=1,b,1
do i=1,a,1
call random_seed
call random_number(x)
x = x * 10 - x * 8
if (small) then
x = x / 40
end if
matr(i,j) = x
enddo
enddo
end subroutine randMatr
end program Kohonen

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-29T19:54:12Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета. Алгоритм был реализован с помощью языка Fortran 90.

Реализация тестировалась со следующими параметрами:

* число процессоров [1 : 128];
* размер входного слоя сети, а также слоя Кохонена (были установлены равными друг другу) [1000 : 4000].

[[Файл:Plot_s2.svg|thumb|600px|center| На рисунке представлен график зависимости времени выполнения от числа процессоров и размерности входных данных]]

[[Файл:Plot_s3.svg|thumb|600px|center| Производительность в зависимости от числа процессоров и размерности входных данных]]

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

Была использована следующая реализация алгоритма.

program Kohonen
implicit none
include 'mpif.h'
integer rank,ierr,size,sizeBlock
integer n,perProc,i,j,k,jmin,jAbsWin
integer iterNum,IOS
real learning_rate
real dist,prom,minDist
real, allocatable :: W(:,:),sample(:,:),maswin(:,:)
real, allocatable :: buf(:,:),win(:)
double precision start,finish
character str

iterNum = 1000
n=1000

learning_rate = 1.0

allocate(W(n,n))
allocate(sample(iterNum,n))
allocate(win(2))

call randMatr(sample,iterNum,n,.FALSE.)
call randMatr(W,n,n,.True.)

call MPI_INIT(IERR)
call MPI_COMM_SIZE(MPI_COMM_WORLD,SIZE,IERR)
call MPI_COMM_RANK(MPI_COMM_WORLD,RANK,IERR)

perProc = n/size
allocate(buf(n,perProc))
allocate(maswin(2,size))
sizeBlock = perProc * n

if (rank .eq. 0) then
start = MPI_WTIME(IERR)
end if

do i=1,IterNum,1
call obnul(buf,n,perProc)
call MPI_SCATTER(W,sizeBlock,MPI_REAL,buf,sizeBlock,MPI_REAL,0,MPI_COMM_WORLD,IERR)

dist = euclDist(sample(i,1:n),buf(1:n,1),n)
do j=1,perProc,1
prom = euclDist(sample(i,1:n),buf(1:n,j),n)
if (prom .le. dist) then
dist = prom
jmin = j + rank*perProc
end if
enddo
win(1) = jmin
win(2) = dist

call MPI_BARRIER(MPI_COMM_WORLD,IERR)

call MPI_GATHER(win,2,MPI_REAL,maswin,2,MPI_REAL,0,MPI_COMM_WORLD,IERR)

if (rank .eq. 0) then
minDist = maswin(2,1)
jAbsWin = maswin(1,1)
do j=2,size,1
if (mindist .ge. maswin(2,j)) then
minDist = maswin(2,j)
jAbsWin = maswin(1,j)
endif
enddo
call modW(W,n,learning_rate,i,jAbsWin)
end if
enddo

if (rank .eq. 0) then
finish = MPI_WTIME(IERR)
open(1,file="Rezult.txt",iostat=IOS)
do while (.NOT. eof(1))
read(1,*) str
enddo
write (1,*) 'Neurons: ',n,'Processes: ',size,'Time: ',finish-start
close(1)
end if

call MPI_FINALIZE(IERR)

!call printm(W,n,n)

deallocate(W,sample,win,maswin,buf)

contains

subroutine printm(W,a,b)
integer a,b,i,j
real W(n,n)

do j=1,b,1
write(*,*)(W(i,j), i=1,a)
enddo
end subroutine printm

subroutine obnul(W,a,b)
integer a,b
integer i,j
real W(a,b)

do j=1,b,1
do i=1,a,1
W(i,j) = 0.0
enddo
enddo
end subroutine obnul

real function euclDist(a,b,n)
integer n,i
real a(n),b(n),res

res = 0
do i = 1,n,1
res = res + (a(i) - b(i)) * (a(i) - b(i))
enddo

euclDist = sqrt(res)
end function euclDist

subroutine modW(W,n,learning_rate,iter,jAbsWin)
integer n,iter,JAbsWin
real learning_rate,W(n,n)
integer i,j

do j=1,n,1
if (j .ne. jAbsWin) then
do i=1,n,1
W(i,j) = W(i,j) + learning_rate/sqrt(iter+1.0)*(W(i,jAbsWin)-W(i,j))
enddo
end if
enddo
end subroutine modW

subroutine randMatr(matr,a,b,small)
integer a,b
logical small
integer i,j
real matr(a,b),x

do j=1,b,1
do i=1,a,1
call random_seed
call random_number(x)
x = x * 10 - x * 8
if (small) then
x = x / 40
end if
matr(i,j) = x
enddo
enddo
end subroutine randMatr
end program Kohonen

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-29T19:53:51Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета. Алгоритм был реализован с помощью языка Fortran 90.

Реализация тестировалась со следующими параметрами:

* число процессоров [1 : 128];
* размер входного слоя сети, а также слоя Кохонена (были установлены равными друг другу) [1000 : 4000].

[[Файл:Plot_s2.svg|thumb|600px|center| На рисунке представлен график зависимости времени выполнения от числа процессоров и размерности входных данных]]

[[Файл:Plot_s3.svg|thumb|600px|center| Производительность в зависимости от числа процессоров и размерности входных данных]]

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

Была использована следующая реализация алгоритма.

program Kohonen
implicit none
include 'mpif.h'
integer rank,ierr,size,sizeBlock
integer n,perProc,i,j,k,jmin,jAbsWin
integer iterNum,IOS
real learning_rate
real dist,prom,minDist
real, allocatable :: W(:,:),sample(:,:),maswin(:,:)
real, allocatable :: buf(:,:),win(:)
double precision start,finish
character str

iterNum = 1000
n=1000

learning_rate = 1.0

allocate(W(n,n))
allocate(sample(iterNum,n))
allocate(win(2))

call randMatr(sample,iterNum,n,.FALSE.)
call randMatr(W,n,n,.True.)

call MPI_INIT(IERR)
call MPI_COMM_SIZE(MPI_COMM_WORLD,SIZE,IERR)
call MPI_COMM_RANK(MPI_COMM_WORLD,RANK,IERR)

perProc = n/size
allocate(buf(n,perProc))
allocate(maswin(2,size))
sizeBlock = perProc * n

if (rank .eq. 0) then
start = MPI_WTIME(IERR)
end if

do i=1,IterNum,1
call obnul(buf,n,perProc)
call MPI_SCATTER(W,sizeBlock,MPI_REAL,buf,sizeBlock,MPI_REAL,0,MPI_COMM_WORLD,IERR)

dist = euclDist(sample(i,1:n),buf(1:n,1),n)
do j=1,perProc,1
prom = euclDist(sample(i,1:n),buf(1:n,j),n)
if (prom .le. dist) then
dist = prom
jmin = j + rank*perProc
end if
enddo
win(1) = jmin
win(2) = dist

call MPI_BARRIER(MPI_COMM_WORLD,IERR)

call MPI_GATHER(win,2,MPI_REAL,maswin,2,MPI_REAL,0,MPI_COMM_WORLD,IERR)

if (rank .eq. 0) then
minDist = maswin(2,1)
jAbsWin = maswin(1,1)
do j=2,size,1
if (mindist .ge. maswin(2,j)) then
minDist = maswin(2,j)
jAbsWin = maswin(1,j)
endif
enddo
call modW(W,n,learning_rate,i,jAbsWin)
end if
enddo

if (rank .eq. 0) then
finish = MPI_WTIME(IERR)
open(1,file="Rezult.txt",iostat=IOS)
do while (.NOT. eof(1))
read(1,*) str
enddo
write (1,*) 'Neurons: ',n,'Processes: ',size,'Time: ',finish-start
close(1)
end if

call MPI_FINALIZE(IERR)

!call printm(W,n,n)

deallocate(W,sample,win,maswin,buf)

contains

subroutine printm(W,a,b)
integer a,b,i,j
real W(n,n)

do j=1,b,1
write(*,*)(W(i,j), i=1,a)
enddo
end subroutine printm

subroutine obnul(W,a,b)
integer a,b
integer i,j
real W(a,b)

do j=1,b,1
do i=1,a,1
W(i,j) = 0.0
enddo
enddo
end subroutine obnul

real function euclDist(a,b,n)
integer n,i
real a(n),b(n),res

res = 0
do i = 1,n,1
res = res + (a(i) - b(i)) * (a(i) - b(i))
enddo

euclDist = sqrt(res)
end function euclDist

subroutine modW(W,n,learning_rate,iter,jAbsWin)
integer n,iter,JAbsWin
real learning_rate,W(n,n)
integer i,j

do j=1,n,1
if (j .ne. jAbsWin) then
do i=1,n,1
W(i,j) = W(i,j) + learning_rate/sqrt(iter+1.0)*(W(i,jAbsWin)-W(i,j))
enddo
end if
enddo
end subroutine modW

subroutine randMatr(matr,a,b,small)
integer a,b
logical small
integer i,j
real matr(a,b),x

do j=1,b,1
do i=1,a,1
call random_seed
call random_number(x)
x = x * 10 - x * 8
if (small) then
x = x / 40
end if
matr(i,j) = x
enddo
enddo
end subroutine randMatr
end program Kohonen

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-22T18:58:45Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при MPI реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

Была использована следующая реализация алгоритма.

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **sample;
double **W;
int inputSize=3;
int numNeurons = 10;
int iterNum = 2000;
double learning_rate = 1;
double radius = 0.2;
double eucledeDist(double vect1[],double vect2[]) {
double sum = 0;
for (int i = 0; i <inputSize; ++i){
sum += (vect1[i]-vect2[i])*(vect1[i]-vect2[i]);
}
return sqrt(sum);
}
double ** getRandomArray(int rows, int cols, int randomize, int init=0){
double ** matr = new double* [rows];
for (int i = 0; i < rows; ++i){
matr[i] = new double[cols]();
}
if (randomize==1){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matr[i][j] = (10*rand()-8*rand())/32767.0;
if (init){matr[i][j] /= 40;}
}
}
}
return matr;
}
int main()
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);
//for each epoch
for (int iter = 0; iter < iterNum; ++iter){
//choose winner
int winner_num = 0;
double winnerDist = eucledeDist(sample[iter],W[0]);
double dist = 0;
for (int i = 1; i < numNeurons; ++i){
dist = eucledeDist(sample[iter],W[i]);
if ( dist < winnerDist) {
winner_num=i;
winnerDist=dist;
};
}
// correct weights
double *winner = W[winner_num];
for (int i = 0; i < numNeurons; ++i){
dist = eucledeDist(winner,W[i]);
if (dist<radius && i!=winner_num) {
for (int j = 0; j < inputSize; ++j){
W[i][j] += learning_rate/sqrt(iter+1) * (winner[j]-W[i][j]);
}
}
}
}
return 0;
}

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-22T18:57:55Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

Была использована следующая реализация алгоритма.

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **sample;
double **W;
int inputSize=3;
int numNeurons = 10;
int iterNum = 2000;
double learning_rate = 1;
double radius = 0.2;
double eucledeDist(double vect1[],double vect2[]) {
double sum = 0;
for (int i = 0; i <inputSize; ++i){
sum += (vect1[i]-vect2[i])*(vect1[i]-vect2[i]);
}
return sqrt(sum);
}
double ** getRandomArray(int rows, int cols, int randomize, int init=0){
double ** matr = new double* [rows];
for (int i = 0; i < rows; ++i){
matr[i] = new double[cols]();
}
if (randomize==1){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matr[i][j] = (10*rand()-8*rand())/32767.0;
if (init){matr[i][j] /= 40;}
}
}
}
return matr;
}
int main()
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);
//for each epoch
for (int iter = 0; iter < iterNum; ++iter){
//choose winner
int winner_num = 0;
double winnerDist = eucledeDist(sample[iter],W[0]);
double dist = 0;
for (int i = 1; i < numNeurons; ++i){
dist = eucledeDist(sample[iter],W[i]);
if ( dist < winnerDist) {
winner_num=i;
winnerDist=dist;
};
}
// correct weights
double *winner = W[winner_num];
for (int i = 0; i < numNeurons; ++i){
dist = eucledeDist(winner,W[i]);
if (dist<radius && i!=winner_num) {
for (int j = 0; j < inputSize; ++j){
W[i][j] += learning_rate/sqrt(iter+1) * (winner[j]-W[i][j]);
}
}
}
}
return 0;
}

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-21T21:25:27Z

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

{{Assignment}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

Была использована следующая реализация алгоритма.

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;
double **sample;
double **W;
int inputSize=3;
int numNeurons = 10;
int iterNum = 2000;
double learning_rate = 1;
double radius = 0.2;
double eucledeDist(double vect1[],double vect2[]) {
double sum = 0;
for (int i = 0; i <inputSize; ++i){
sum += (vect1[i]-vect2[i])*(vect1[i]-vect2[i]);
}
return sqrt(sum);
}

double ** getRandomArray(int rows, int cols, int randomize, int init=0){
double ** matr = new double* [rows];
for (int i = 0; i < rows; ++i){
matr[i] = new double[cols]();
}
if (randomize==1){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matr[i][j] = (10*rand()-8*rand())/32767.0;
if (init){matr[i][j] /= 40;}
}
}
}
return matr;
}

int main()
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

//for each epoch
for (int iter = 0; iter < iterNum; ++iter){

//choose winner
int winner_num = 0;
double winnerDist = eucledeDist(sample[iter],W[0]);
double dist = 0;
for (int i = 1; i < numNeurons; ++i){
dist = eucledeDist(sample[iter],W[i]);
if ( dist < winnerDist) {
winner_num=i;
winnerDist=dist;
};
}

// correct weights
double *winner = W[winner_num];
for (int i = 0; i < numNeurons; ++i){
dist = eucledeDist(winner,W[i]);
if (dist<radius && i!=winner_num) {
for (int j = 0; j < inputSize; ++j){
W[i][j] += learning_rate/sqrt(iter+1) * (winner[j]-W[i][j]);
}

}
}
}
return 0;
}

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-21T21:24:23Z

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

{{Assignment}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

Была использована следующая реализация алгоритма.

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
using namespace std;

double **sample;
double **W;
int inputSize=3;
int numNeurons = 10;
int iterNum = 2000;
double learning_rate = 1;
double radius = 0.2;

double eucledeDist(double vect1[],double vect2[]) {
double sum = 0;
for (int i = 0; i <inputSize; ++i){
sum += (vect1[i]-vect2[i])*(vect1[i]-vect2[i]);
}
return sqrt(sum);
}

double ** getRandomArray(int rows, int cols, int randomize, int init=0){
double ** matr = new double* [rows];
for (int i = 0; i < rows; ++i){
matr[i] = new double[cols]();
}
if (randomize==1){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matr[i][j] = (10*rand()-8*rand())/32767.0;
if (init){matr[i][j] /= 40;}
}
}
}
return matr;
}

int main()
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

//for each epoch
for (int iter = 0; iter < iterNum; ++iter){

//choose winner
int winner_num = 0;
double winnerDist = eucledeDist(sample[iter],W[0]);
double dist = 0;
for (int i = 1; i < numNeurons; ++i){
dist = eucledeDist(sample[iter],W[i]);
if ( dist < winnerDist) {
winner_num=i;
winnerDist=dist;
};
}

// correct weights
double *winner = W[winner_num];
for (int i = 0; i < numNeurons; ++i){
dist = eucledeDist(winner,W[i]);
if (dist<radius && i!=winner_num) {
for (int j = 0; j < inputSize; ++j){
W[i][j] += learning_rate/sqrt(iter+1) * (winner[j]-W[i][j]);
}

}
}
}

return 0;
}

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-18T18:11:25Z

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

{{Assignment}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-14T17:23:35Z

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

{{Assignment}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

Как было описано в [[1.8 | п. 1.8]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети при OpenMP реализации.
[[Файл:Openmp1.PNG|thumb|600px|center| График зависимости времени выполнения от числа потоков и размера сети]]

Гистограмма ускорения выполнения алгоритма с различными размерами карт. Хорошо видно, что наибольший эффект достигается на 6-8 потоках.
[[Файл:Openmp2.PNG|thumb|600px|center| Гистограмма ускорения]]

Сравнительные результаты реализаций самоорганизующихся карт с помощью Fortran-OpenMP и C-Thread:
[[Файл:Compare.PNG|thumb|600px|center| Время выполнения (сверху) и ускорение (снизу) в зависимости от числа процессоров]]

Как можно увидеть, на участках от 1 ядра (потока) до 8 программа хорошо масштабируема, но при увеличении количества ядер (потоков) до 9 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-13T21:29:29Z

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

{{Assignment|Teplov}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

[[Файл:Openmp1.PNG|thumb|600px|center| описание]]

[[Файл:Openmp2.PNG|thumb|600px|center| описание]]

[[Файл:Compare.PNG|thumb|600px|center| описание]]

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-13T21:28:49Z

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

{{Assignment|Teplov}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

[[Файл:Openmp1.png|thumb|600px|center| описание]]

[[Файл:Openmp2.png|thumb|600px|center| описание]]

[[Файл:Compare.png|thumb|600px|center| описание]]

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Файл:Compare.PNG

2016-11-13T21:28:31Z

Kravtsovkirill:

Файл:Openmp2.PNG

2016-11-13T21:28:10Z

Kravtsovkirill:

Файл:Openmp1.PNG

2016-11-13T21:27:08Z

Kravtsovkirill:

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-11-13T21:25:06Z

Kravtsovkirill:

{{Assignment|Teplov}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 2.4, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.4, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-31T18:04:36Z

Kravtsovkirill:

{{Assignment}}
{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-31T18:02:41Z

Kravtsovkirill:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.6, 1.7, 1.8, 1.9, 1.10, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-31T18:00:43Z

Kravtsovkirill: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.7, 1.8, 1.9, 1.10, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.

'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-31T18:00:26Z

Kravtsovkirill: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.7, 1.8, 1.9, 1.10, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).
'''Объем входные данных:''' так как обучение происходит не на всем входном векторе, а только на количестве векторов равном <math>T</math>, то алгоритм может быть организован так, чтобы принять на выход только <math>T</math> случайных векторов из исходной выборки. И, соответственно, объем входных данных можно считать равным <math>m*T</math>.

'''Выходные данные:''' матрица весов.
'''Объем выходных данных:''' равен <math>m*k</math>

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-31T17:20:38Z

Kravtsovkirill: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] (1.1, 1.2, 1.4, 1.5, 1.6, 1.7, 1.9, 1.10) и [[Участник:Kravtsovkirill|Кирилл Кравцов]] (1.2, 1.3, 1.7, 1.8, 1.9, 1.10, 2.7)

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

==== Алгоритм обучения сети без учителя====

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

==== Инициализация начальных весов====

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

==== Функция соседства нейронов====

Функции от расстояния применяются двух видов:

Константа:
<math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса:
<math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

==== Функция скорости обучения сети====

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), число "эпох" <math>T</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

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

2016-10-15T17:46:35Z

Kravtsovkirill: /* Перенос */

== Перенос ==
Статья: [[Кластеризация сетями Кохонена]]
Выполняют: [[Участник:Kravtsovkirill| Кравцов Кирилл]] и [[Участник:Emaksimov| Максимов Егор]]

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:pahom | Кочетков Павел]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Участница:JuliaA|Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Участник:GlotovES| Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

Статья: [[Плотностный алгоритм кластеризации DBSCAN]]
Выполняют: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

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

2016-10-15T17:45:08Z

Kravtsovkirill: /* Перенос */

== Перенос ==
Статья: [[Кластеризация сетями Кохонена]]
Выполняют: Кравцов Кирилл и Максимов Егор

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:pahom | Кочетков Павел]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Участница:JuliaA|Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Участник:GlotovES| Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

Статья: [[Плотностный алгоритм кластеризации DBSCAN]]
Выполняют: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:41:25Z

Kravtsovkirill:

{{Assignment}}

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:32:18Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>n</math> евклидовых норм, (функция <math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>2m-1</math> операций сложения, <math>m</math> операций умножения и один квадратный корень. (<math>m</math> - размерность входных векторов) для вычисления всех норм
*количество операций на корректировку весов одного нейрона можно оценить как <math>O(m)</math>.

Итак, как уже было сказано, общая последовательная сложность алгоритма составляет <math>O(Tmn)</math>, где <math>T</math> - количество эпох обучения (итераций), <math>m</math> - размерность входных векторов (иначе говоря, количество нейронов во входном слое сети Кохонена), <math>n</math> - количество кластеров (иначе говоря, количество нейронов во втором слое сети - слое Кохонена).

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:22:24Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|550px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:21:56Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|450px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:21:30Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:21:06Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:
#Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
#Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>: <center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле: <center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:19:35Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

1. Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

2. Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
3. Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:18:42Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

1. Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
2. Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
3. Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:18:10Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.
# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:17:35Z

Kravtsovkirill: /* Литература */

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.
# Нейский И.М. Классификация и сравнение методов кластеризации http://it-claim.ru/Persons/Neyskiy/Article2_Neiskiy.pdf

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:13:30Z

Kravtsovkirill:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T17:13:04Z

Kravtsovkirill:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рис. 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Риc. 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

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

# Teuvo Kohonen, Self-Organizing Maps/Helsinki University of Technology,1997/Second Edition.

Участник:Kravtsovkirill

2016-10-15T12:39:08Z

Kravtsovkirill: Новая страница: «ВМК МГУ, 620 группа»

ВМК МГУ, 620 группа

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T12:35:33Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(mn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 1. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 2. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Рис. 3. Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Рис. 4. Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Рис. 5. Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T12:32:45Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(mnT)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(T*log(max(m,n)))</math>
| pf_width = <math>O(max(mk,mn))</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кирилл Кравцов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый этап алгоритма]]

'''Второй этап''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Второй этап алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(T * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T12:18:49Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{i} \neq \mathbf{c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Второй ярус алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(t * \log max(m,n))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T12:07:28Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

=== Макроструктура алгоритма ===
Алгоритм кластеризации можно разбить на следующие этапы:
*Инициализация <math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

*Цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:
# <math>\mathbf{X} \leftarrow ChooseRandomVector(\mathbf{V})</math>
#Вложенный цикл, в котором осуществляется вычисление расстояний <math>\mathbf{D_i} \leftarrow CalculateEucledeNorm(X, \mathbf{W_i})</math>
#Выбор победителя <math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D_i})</math>
#Вложенный цикл, в котором осуществляется корректировка весов <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t:=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} := ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} := CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} := ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i:=1 \ \mathbf{TO} \ N \ \mathbf{DO} \ \mathbf{AND} \ \mathbf{W_i} \neq \mathbf{W_c}</math>
<math>\mathbf{W_i(t+1)} := CorrectWeights(\mathbf{W_i(t)}, \mathbf{W_c})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Второй ярус алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов.
Этап Winner заключается в поиске минимума по подсчитанным расстояниям для определения нейрона-победителя. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>.
Этап Correct состоит из нескольких операций, но асимптотически сложность определяет именно подсчет евклидова расстояния. Аналогично получаем, что сложность данного этапа составляет <math>O(\log m)</math>.

Итоговую параллельную сложность кластеризации сетями Кохонена можно оценить как <math>O(t * \log nm^{2})</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T11:59:28Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Второй ярус алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + PComplexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>PComplexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Этап Norm заключается в параллельном вычислении евклидовых норм. Сложность этого этапа можно оценить с учетом доступности неограниченного числа процессоров как <math>O(\log m)</math>, где <math>m</math> - длина векторов. Параллельная сложность реализации операции нахождения минимума из <math>n</math> элементов определяется как <math>O(\log n)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log mn)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T11:06:18Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

[[Файл:Graph4.png|thumb|600px|center| Второй ярус алгоритма]]

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

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

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

Итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>Complexity = T * (PComplexity_{Norm} + Complexity_{Winner} + PComplexity_{Correct})</math>, где <math>PComplexity_{Norm}</math> - параллельная сложность поиска евклидовых расстояний для определения нейрона-победителя, <math>PComplexity_{Correct}</math> - параллельная сложность обновления весов нейронов, <math>Complexity_{Winner}</math> - сложность глобального поиска минимального значения расстояния, <math>T</math> - количество эпох (итераций) алгоритма.

Параллельная сложность этапа распределения векторов по кластерам с учетом доступности неограниченного числа процессоров вычисляется следующим образом: так как вычисление значений <math>\big \| x_i - \mu^{(t)}_j \big \|^2</math> для каждой пары векторов <math>x_i, i = 1, 2, ..., n</math> и <math>\mu^{(t)}_j, j = 1, 2, ..., k</math> можно выполнять независимо и для вычисления этого выражения требуется <math>O(\log d)</math> операций в соответствии с [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения сумм элементов массива сдваиванием]]. Параллельная сложность реализации операции нахождения минимума из <math>k</math> элементов определяется как <math>O(\log k)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log kd)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T10:56:33Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

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

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

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

В силу особенностей алгоритма k средних порядок выполнения основных этапов существенен, что не позволяет выполнять их параллельно. Таким образом, итоговая сложность параллельного алгоритма будет определяться, исходя из формулы <math>T = t * (T_{as} + T_{up})</math>, где <math>T_{as}</math> - параллельная сложность этапа распределения векторов по кластерам, <math>T_{up}</math> - параллельная сложность этапа обновления центров масс кластеров, <math>t</math> - общее число итераций алгоритма.

Параллельная сложность этапа распределения векторов по кластерам с учетом доступности неограниченного числа процессоров вычисляется следующим образом: так как вычисление значений <math>\big \| x_i - \mu^{(t)}_j \big \|^2</math> для каждой пары векторов <math>x_i, i = 1, 2, ..., n</math> и <math>\mu^{(t)}_j, j = 1, 2, ..., k</math> можно выполнять независимо и для вычисления этого выражения требуется <math>O(\log d)</math> операций в соответствии с [[Нахождение_частных_сумм_элементов_массива_сдваиванием | параллельной реализацией нахождения сумм элементов массива сдваиванием]]. Параллельная сложность реализации операции нахождения минимума из <math>k</math> элементов определяется как <math>O(\log k)</math>. Таким образом, сложность этапа распределения векторов по кластерам <math>O(\log kd)</math>.

Параллельная сложность этапа обновления центров масс кластеров вычисляется следующим образом: так как обновление значений каждого из центров масс кластеров можно выполнять независимо, параллельная сложность определяется сложностью обновления центра масс самого большого кластера. В худшем случае для нахождения значения выражения <math>\mu^{(t+1)}_j = \frac{1}{|S^{(t)}_i|} \sum_{x_j \in S^{(t)}_i} x_j </math> требуется <math>O(\log n)</math> операций.

С учетом вышесказанного, итоговая параллельная сложность алгоритма k средних определяется выражением <math>O(t * \log kdn)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T10:51:13Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

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

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

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

[[Файл:Graph3.png|thumb|600px|center| Первый ярус алгоритма]]

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T10:50:25Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.
[[Файл:Graph3.png|thumb|600px|center| Параллельная схема поиска победителя]]

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

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

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

'''Второй ярус''' состоит их <math>n</math> параллельных операций коррекций весов.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T10:35:11Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

=== Информационный граф ===
Общая схема работы алгоритма выглядит следующим образом:
[[Файл:Graph2.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]
Здесь In - входные данные, Init - шаг, на котором происходит инициализация весов, Norm - вычисление расстояний, Win - выбор победителя, Correct - корректировка весов, Out - выходные данные.

Информационный граф представлен на рисунке ниже.

'''Первый ярус''' состоит из <math>M</math> параллельных операций 1, 2, совершаемых в цикле <math>c</math> раз для каждого кластера.

'''Операция 1''': <math>w_{ij}^m</math>, где <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

'''Операция 2''': <math>w_{ij}^m*X_i</math>

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем вектор размера <math>1</math> x <math>c</math> и матрицу размера <math>d</math> x <math>c</math>.
Далее совершаем поэлементное сложение векторов и матриц соответственно, а затем делим каждый столбец в матрице на соответствующий элемент в векторе.

'''Второй ярус''' состоит их <math>M</math> параллельных операций 3, 4, 5 также совершаемых в цикле <math>c</math> раз.

'''Операция 4''': обновление значения <math>w_{ij}</math> по указанной в разделе 1.2 в пункте 5 формуле.

'''Операция 5''': <math>maximum = max(|w_{ij} - w_{ij}^{prev}|, maximum)</math>.

'''Операция 6''': <math>w_{ij}^{prev} = w_{ij}</math>.

Здесь <math>j</math> - номер итерации в цикле, <math>i</math> - номер параллельной ветви.

На выходе из каждой ветки получаем число <math>maximum</math>. Далее находим максимальное значение из полученных величин для каждой ветки. Затем проверяем условие останова алгоритма.

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T09:48:56Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро алгоритма состоит из двух шагов, повторяющихся каждую итерацию (эпоху):
*Вычисление расстояния от случайно выбранного вектора <math>x(t)</math> до каждого нейрона и выбор нейрона с наименьшим расстоянием. Т.е. вычисление <math>n</math> евклидовых расстояний и сортировка полученного массива расстояний. Сложность евклидового расстояния растет линейно с увеличением длины вектора. Следовательно получаем сложность данного шага <math>O(mn)</math>.
*Обновление весов всех нейронов. Пусть используется гауссовская функция для вычисления расстояний между нейронами. Сложность обновления веса одного нейрона линейно зависит от <math>m</math>. Т.е. сложность данного шага также <math>O(mn)</math>.

В итоге получаем, что для всего алгоритма с количеством эпох равным <math>T</math> сложность составляет <math>O(Tmn)</math>.

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T09:35:52Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

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

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com Matlab realization]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf SAS EM]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T09:34:59Z

Kravtsovkirill:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>mn</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

Авторы страницы [[Участник:Emaksimov|Егор Максимов]] и [[Участник:Kravtsovkirill|Кравц Кириллов]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|right|Рисунок 2. Кохонен, Теуво.]]
Она представляет собой двухслойную сеть. Каждый нейрон первого (распределительного) слоя соединен со всеми нейронами второго (выходного) слоя, которые расположены в виде двумерной решетки. Для визуализации топологии слоя Кохонена используют либо шестиугольные, либо прямоугольные ячейки, в которых распологаются нейроны. Шестиугольные ячейки часто являются более предпочтительными, так как расстояние от центра выбранной ячейки до ее соседей одинаково.Нейроны выходного слоя называются кластерными элементами, их количество определят максимальное количество групп, на которые система может разделить входные данные. Увеличивая количество нейронов второго слоя можно увеличивать детализацию результатов процесса кластеризации.

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

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

=== Математическое описание алгоритма ===
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]
Пусть имеется некоторое множество векторов <math> x^{(i)}=(x_1^{(i)},x_2^{(i)},...,x_m^{(i)}) \in \mathbb{R}^m, i=1, \dots, k</math>. Заранее зададим количество кластеров равным <math>n</math>. Соответственно, Карта Кохонена представляет собой двухслойную fully-connected нейронную сеть, где первый слой состоит из <math>m</math> нейронов, а второй - из <math>n</math>.
Каждый j-ый нейрон описывается вектором весов <math> w_j=(w_{1j},w_{2j},...,w_{mj}), j=1, \dots, n</math>.

'''Алгоритм обучения сети без учителя'''

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. Сначала следует инициализировать векторы весов. Далее определенное количество раз (эпох) производятся следующие действия:

# Случайным образов выбирается вектор <math>x(t)</math> из входных данных.

# Выбирается нейрон-победитель <math>w_c</math> "наиболее похожий" (по евклидову расстоянию) на вектор <math>x(t)</math>:
<center> <math> ||x(t)-w_c||=\min\limits_{i}(||x(t)-w_i(t)||)</math>. </center>
# Веса всех нейронов обновляются по формуле:
<center> <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, </center>
где <math>t</math> - номер эпохи, <math> h_{ic}(t)</math>- функция соседства нейронов,
<math>\alpha (t)</math> - функция скорости обучения сети.

'''Инициализация начальных весов'''

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

'''Функция соседства нейронов'''

Функции от расстояния применяются двух видов:

Константа: <math>
h(d,t) = \begin{cases}
c, & \mbox{if } n \ d<=\delta \\
0, & \mbox{if } n \ d>\delta
\end{cases}</math>

Функция Гаусса: <math>h_{ic}(t)=\exp(-\frac{\|r_c-r_i\|^2}{2\sigma^2(t)})</math>,

где <math>r_i</math> определяет положение <math>i</math>-го нейрона в сетке

'''Функция скорости обучения сети'''

Главное требование к ней - монотонное убывание при возрастании <math>t</math> для замедления темпов вариации весов нейронов слоя Кохонена.
Функция может быть задана, например, как <math>\alpha(t)=\frac{A}{B+t}</math>, где <math>A</math> и <math>B</math> - некоторые константы.

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

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

<math>\mathbf{W} \leftarrow ComputeInitialWeights(\mathbf{W})</math>

Далее следует цикл, повторяющийся <math>T_{max}</math> (максимальное число "эпох") раз:

# <math>\mathbf{W_i} \leftarrow CalculateEucledeNorm(\mathbf{W_i})</math>
# <math>\mathbf{W_i(t+1)}\leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

=== Схема реализации последовательного алгоритма ===
Пусть <math>\mathbf{W}</math> - матрица весов, <math>T_{max}</math> - максимальное число "эпох", <math>k</math> - мощность входного множества, <math>N</math> - число нейронов выходного слоя. Тогда схема реализации последовательного алгоритма будет выглядеть следующим образом:

<math>\mathbf{W} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathbf{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{D} \leftarrow CalculateEucledeNorm(\mathbf{X}, \mathbf{W_i})</math>
<math>\mathbf{FOR} \ i=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>\mathbf{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

Рассмотрим вычислительную сложность описанного алгоритма. Основная часть операций алгоритма приходится на вложенные циклы, где
*выполняется вычисление <math>N</math> евклидовых норм, функция (<math>CalculateEucledeNorm</math>), на вычисление каждой из которых требуется по <math>m*N</math> операций умножения и <math>m*(N-1)</math> операций сложения (<math>m</math> - размерность входных векторов) для вычисления всех норм
*на сравнение <math>N</math> вещественных чисел (функция <math>ChooseWinner</math>)
*на корректировку весов - порядка <math>m*N</math> операций

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <math>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

'''Выходные данные:''' матрица весов

=== Свойства алгоритма ===
[[глоссарий#Вычислительная мощность|''Вычислительная мощность'']]
Вычислительная мощность алгоритма кластеризации сетями Кохонена равна <math>\frac{m*n*T}{m*k+m*n} = \frac{n*T}{k+n}</math>, где, напомним, <math>T</math> - число итераций, <math>n</math> - число нейронов выходного слоя, <math>k</math> - мощность входного множества.

[[глоссарий#Детерминированность |''Детерминированность'']] и [[глоссарий#Устойчивость |''Устойчивость'']] 
Описанный алгоритм кластеризации случайно выбирает элемент входного множества, следовательно, не является детерминированным. Как и все простые сети, построенный алгоритм является устойчивым.

''Сильные и слабые стороны алгоритма''

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

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

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

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

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

Последовательные реализации:

* [https://cran.r-project.org/web/packages/kohonen/ kohonen] Бибилиотека для R
* [https://pypi.python.org/pypi/kohonen kohonen] Бибилиотека для Python
* [http://knnl.sourceforge.net/ KNNL]: C++ бибилиотека.
* [https://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html?requestedDomain=www.mathworks.com]: Реализация в Matlab.
* [http://jknnl.sourceforge.net/ JKNNL]: Библиотека для Java.
* [https://support.sas.com/documentation/onlinedoc/miner/casestudy_59123.pdf]: Реализация в SAS Enterprise Miner

Параллельные реализации:

* [https://github.com/peterwittek/somoclu Somoclu]: Библиотека для Python, R, Julia, и Matlab с поддержкой OpenMP, MPI и CUDA.

Участник:Emaksimov/Кластеризация сетями Кохонена

2016-10-15T09:11:33Z

Kravtsovkirill: