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

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

2016-11-29T19:13:34Z

Emaksimov: /* Программная реализация алгоритма */

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

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

[[Файл:Plot_s3.svg|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-29T19:06:14Z

Emaksimov: /* Программная реализация алгоритма */

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

[[Файл:Plot_s2.svg|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-29T19:05:44Z

Emaksimov: /* Программная реализация алгоритма */

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

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

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

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

* [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-29T17:55:34Z

Emaksimov: /* Программная реализация алгоритма */

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

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

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

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

* [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-29T17:54:34Z

Emaksimov: /* Программная реализация алгоритма */

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

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

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

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

* [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-29T09:46:42Z

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

{{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 и более происходит увеличение времени выполнения и [[Ускорение| ускорение]] программы уменьшается вследствие запроса на слишком большое количество ресурсов при относительно небольшом объёме входных данных.

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

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

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

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

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

* [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-29T09:27:05Z

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

{{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>
#include <mpi.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(int argc, char** argv)
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

MPI_Init(&argc, &argv);
int MPI_myId, MPI_nProcs;
MPI_Comm_rank(MPI_COMM_WORLD, &MPI_myId);
MPI_Comm_size(MPI_COMM_WORLD, &MPI_nProcs);
MPI_Barrier(MPI_COMM_WORLD);
int MPI_dataPerProc = ceil(inputSize / (1.0*MPI_nProcs));
double start = MPI_Wtime();
//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;
};
}
MPI_Barrier(MPI_COMM_WORLD);
// 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]);
}
}
}
MPI_Barrier(MPI_COMM_WORLD);
}
double finish = MPI_Wtime();
double runtime = finish - start;
MPI_Finalize();
return 0;
}

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

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

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

* [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-23T09:09:57Z

Emaksimov:

{{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>
#include <mpi.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(int argc, char** argv)
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

MPI_Init(&argc, &argv);
int MPI_myId, MPI_nProcs;
MPI_Comm_rank(MPI_COMM_WORLD, &MPI_myId);
MPI_Comm_size(MPI_COMM_WORLD, &MPI_nProcs);
MPI_Barrier(MPI_COMM_WORLD);
int MPI_dataPerProc = ceil(inputSize / (1.0*MPI_nProcs));
double start = MPI_Wtime();
//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;
};
}
MPI_Barrier(MPI_COMM_WORLD);
// 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]);
}
}
}
MPI_Barrier(MPI_COMM_WORLD);
}
double finish = MPI_Wtime();
double runtime = finish - start;
MPI_Finalize();
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-22T20:12:58Z

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

{{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>
#include <mpi.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(int argc, char** argv)
{
double **sample = getRandomArray(iterNum,inputSize,1,0);
double **W = getRandomArray(numNeurons,inputSize,1,1);

//for each epoch
MPI_Init(&argc, &argv);
int MPI_myId, MPI_nProcs;
MPI_Comm_rank(MPI_COMM_WORLD, &MPI_myId);
MPI_Comm_size(MPI_COMM_WORLD, &MPI_nProcs);
MPI_Barrier(MPI_COMM_WORLD);
int MPI_dataPerProc = ceil(inputSize / (1.0*MPI_nProcs));
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;
};
}
MPI_Barrier(MPI_COMM_WORLD);
// 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]);
}
}
}
MPI_Barrier(MPI_COMM_WORLD);
}

MPI_Finalize();
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-14T11:26:39Z

Emaksimov: Отмена правки 16945, сделанной участником Emaksimov (обс.)

{{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]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети.
[[Файл: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-14T11:26:11Z

Emaksimov: Отмена правки 16945, сделанной участником Emaksimov (обс.)

{{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> - мощность входного множества.

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

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

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

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

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

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

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

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети.
[[Файл: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-14T11:16:59Z

Emaksimov:

{{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]], для алгоритма кластеризации имеет место массовый параллелизм, поскольку основные этапы алгоритма (поиск евклидовых расстояний для определения нейрона-победителя и обновление весов) информационно независимы, что означает хорошую масштабируемость алгоритма.

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

Ниже представлен график зависимости времени выполнения от числа потоков и размера сети.
[[Файл: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-14T05:54:05Z

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

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

2016-11-14T00:49:38Z

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

{{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| График зависимости времени выполнения от числа потоков и размера сети]]

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

Сравнительные результаты реализаций самоорганизующихся карт с помощью Fortran-OpenMP и C-Thread:
[[Файл: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-10-30T12:50:15Z

Emaksimov: /* Функция соседства нейронов */

{{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>\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-30T09:26:15Z

Emaksimov:

{{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>\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-30T09:19:48Z

Emaksimov:

{{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-15T12:37:18Z

Emaksimov:

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

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

2016-10-15T12:35:29Z

Emaksimov:

{{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| Общая схема работы алгоритма кластеризации]]
Здесь 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:34:17Z

Emaksimov:

{{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|Рисунок 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:33:39Z

Emaksimov:

{{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(m,n))</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:30:17Z

Emaksimov:

{{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:25:32Z

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

{{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:57Z

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

{{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 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-15T12:06:39Z

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

{{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> - длина векторов. Параллельная сложность реализации операции нахождения минимума из <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-15T12:05:46Z

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

{{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} \leftarrow 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> - длина векторов. Параллельная сложность реализации операции нахождения минимума из <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-15T12:03:07Z

Emaksimov: /* Макроструктура алгоритма */

{{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} \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:05:09Z

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

{{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| Второй ярус алгоритма]]

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

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

Алгоритм кластеризации 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:40:04Z

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

{{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>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-15T10:16:18Z

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

{{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>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:10:08Z

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

{{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> операций

=== Информационный граф ===
[[Файл:Graph1.png|thumb|400px|center| Общая схема работы алгоритма кластеризации]]

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <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:09:48Z

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

{{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> операций

=== Информационный граф ===
[[Файл:Graph1.jpg|thumb|400px|center| Общая схема работы алгоритма кластеризации]]

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <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:02:58Z

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

{{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> операций

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные:''' множество входных векторов (нейронов первого уровня), множество кластеров (выходов, нейронов второго уровня), максимальное число "эпох" <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:29:24Z

Emaksimov: /* Свойства алгоритма */

{{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> - мощность входного множества.

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

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

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

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

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

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

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

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

2016-10-15T09:29:08Z

Emaksimov: /* Свойства алгоритма */

{{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> - мощность входного множества.

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

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

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

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

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

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

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

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

2016-10-15T09:28:24Z

Emaksimov: /* Свойства алгоритма */

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

2016-10-15T09:17:32Z

Emaksimov: /* Свойства алгоритма */

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

2016-10-15T09:15:49Z

Emaksimov: /* Свойства алгоритма */

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

2016-10-15T09:08:33Z

Emaksimov:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>nk</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> (в случае, если выбрана простая константа).

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

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

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

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

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

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

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

2016-10-15T09:01:23Z

Emaksimov:

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(Tmn)</math>
| input_data = <math>mk</math>
| output_data = <math>nk</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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> (в случае, если выбрана простая константа).

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

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

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

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

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

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

2016-10-15T08:31:58Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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> (в случае, если выбрана простая константа).

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

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

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

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

2016-10-15T07:48:08Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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>T_{max}</math>, константа <math> \delta </math>, константы <math>A</math> и <math>B</math>, константа <math>c</math> (в случае, если выбрана простая константа).

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

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

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

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

2016-10-15T07:47:50Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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{W_c} \leftarrow ChooseWinner(\mathbf{D})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

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

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

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

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

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

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

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

2016-10-15T07:47:28Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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} \ t=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{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

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

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

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

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

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

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

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

2016-10-15T07:47:16Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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} \ t=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{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

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

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

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

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

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

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

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

2016-10-15T07:28:11Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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 \mathcal{X} \leftarrow ChooseRandomVector\left( \{1, \dots, k\} \right)</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ N \ \mathbf{DO}</math>
<math>CalculateEucledeNorm(\mathbf{W_i})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

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

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

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

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

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

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

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

2016-10-14T22:34:06Z

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

{{algorithm
| name = Кластеризация сетями Кохонена
| serial_complexity = <math>O(tnkd)</math>
| input_data = <math>nd</math>
| output_data = <math>n</math>
| pf_height = <math>O(t * \log kdn)</math>
| pf_width = <math>O(kdn)</math>
}}

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (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>\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} := InitializeWeights()</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math> \quad \mathcal{X} \leftarrow ChooseRandomVector\left( \{1, \dots, N\} \right)</math>
<math>\mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO}</math>
<math>CalculateEucledeNorm(\mathbf{W_i})</math>
<math>\mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)})</math>

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

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

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

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

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

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

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

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

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

2016-10-14T21:37:33Z

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

'''Кластеризация сетями Кохонена'''
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|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>.
# Веса всех нейронов обновляются по формуле: <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, где
<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_{ci}(t)=\alpha(t)\cdot\exp(-\frac{\|r_c-r_k\|^2}{2\sigma^2(t)})</math>

где <math>0<\alpha(t)<1</math> — обучающий сомножитель, монотонно убывающий с каждой последующей итерацией (то есть определяющий приближение значения векторов веса нейрона-победителя и его соседей к наблюдению; чем больше шаг, тем меньше уточнение); 
<math>r_k</math>, <math>r_c</math> — координаты узлов <math>W_k(t)</math> и <math>W_c(t)</math> на карте;

<math>\sigma(t)</math> — сомножитель, уменьшающий количество соседей с итерациями, монотонно убывает.
Параметры <math>\alpha</math>, <math>\sigma</math> и их характер убывания задаются аналитиком.

Более простой способ задания функции соседства:

<math>h_{ci}(t)=\alpha(t)</math>,

если <math>W_k(t)</math> находится в окрестности <math>W_c(t)</math> заранее заданного аналитиком радиуса, и 0 в противном случае.
Функция <math>h(t)</math> равна <math>\alpha(t)</math> для BMU и уменьшается с удалением от BMU.

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

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

<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>
\begin{align}
\mathbf{W} := &InitializeWeights() \\
\mathbf{FOR} & \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& \mathcal{X} \leftarrow ChooseRandomVector\left( \{1, \dots, N\} \right) \\
& \mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& CalculateEucledeNorm(\mathbf{W_i}) \\
&
& \mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)}) \\

\end{align}
</math>

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

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

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

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

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

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

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

2016-10-14T21:34:02Z

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

'''Кластеризация сетями Кохонена'''
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|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>.
# Веса всех нейронов обновляются по формуле: <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, где
<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_{ci}(t)=\alpha(t)\cdot\exp(-\frac{\|r_c-r_k\|^2}{2\sigma^2(t)})</math>

где <math>0<\alpha(t)<1</math> — обучающий сомножитель, монотонно убывающий с каждой последующей итерацией (то есть определяющий приближение значения векторов веса нейрона-победителя и его соседей к наблюдению; чем больше шаг, тем меньше уточнение); 
<math>r_k</math>, <math>r_c</math> — координаты узлов <math>W_k(t)</math> и <math>W_c(t)</math> на карте;

<math>\sigma(t)</math> — сомножитель, уменьшающий количество соседей с итерациями, монотонно убывает.
Параметры <math>\alpha</math>, <math>\sigma</math> и их характер убывания задаются аналитиком.

Более простой способ задания функции соседства:

<math>h_{ci}(t)=\alpha(t)</math>,

если <math>W_k(t)</math> находится в окрестности <math>W_c(t)</math> заранее заданного аналитиком радиуса, и 0 в противном случае.
Функция <math>h(t)</math> равна <math>\alpha(t)</math> для BMU и уменьшается с удалением от BMU.

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

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

<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>
\begin{align}
\mathbf{W} := &InitializeWeights() \\
\mathbf{FOR} & \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& \mathcal{X} \leftarrow ChooseRandomVector\left( \{1, \dots, N\} \right) \\
& \mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& CalculateEucledeNorm(\mathbf{W_i}) \\
& \mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)}) \\

\end{align}
</math>

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

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

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

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

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

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

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

2016-10-14T21:33:46Z

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

'''Кластеризация сетями Кохонена'''
[[Файл:FNaEm.png|thumb|350px|right|Рисунок 1. Кластеризация сетями Кохонена]]

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

=== Общее описание алгоритма ===
'''Искусственная нейронная сеть Кохонена''' или самоорганизующаяся карта признаков (SOM) была предложена финским исследователем Тойво Кохоненом в начале 1980-х годов.
[[Файл:Teuvokohonen.jpg|thumb|150px|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>.
# Веса всех нейронов обновляются по формуле: <math> w_i(t+1)=w_i(t)+\alpha(t)h_{ic}(t)||x(t)-w_i(t)||</math>, где
<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_{ci}(t)=\alpha(t)\cdot\exp(-\frac{\|r_c-r_k\|^2}{2\sigma^2(t)})</math>

где <math>0<\alpha(t)<1</math> — обучающий сомножитель, монотонно убывающий с каждой последующей итерацией (то есть определяющий приближение значения векторов веса нейрона-победителя и его соседей к наблюдению; чем больше шаг, тем меньше уточнение); 
<math>r_k</math>, <math>r_c</math> — координаты узлов <math>W_k(t)</math> и <math>W_c(t)</math> на карте;

<math>\sigma(t)</math> — сомножитель, уменьшающий количество соседей с итерациями, монотонно убывает.
Параметры <math>\alpha</math>, <math>\sigma</math> и их характер убывания задаются аналитиком.

Более простой способ задания функции соседства:

<math>h_{ci}(t)=\alpha(t)</math>,

если <math>W_k(t)</math> находится в окрестности <math>W_c(t)</math> заранее заданного аналитиком радиуса, и 0 в противном случае.
Функция <math>h(t)</math> равна <math>\alpha(t)</math> для BMU и уменьшается с удалением от BMU.

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

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

<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>
\begin{align}
\mathbf{W} := &InitializeWeights() \\
\mathbf{FOR} & \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& \mathcal{X} \leftarrow ChooseRandomVector\left( \{1, \dots, N\} \right) \\
& \mathbf{FOR} \ t=1 \ \mathbf{TO} \ T_{max} \ \mathbf{DO} \\
& \quad CalculateEucledeNorm(\mathbf{W_i}) \\
& \quad & \mathbf{W_i(t+1)} \leftarrow CorrectWeights(\mathbf{W_i(t)}) \\

\end{align}
</math>

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

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

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

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

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

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