Исследование алгоритмов обучения нейронных сетей 'с учителем'

КУРСОВАЯ РАБОТА

Исследование алгоритмов обучения нейронных сетей "с учителем"

СОДЕРЖАНИЕ

Введение

1. Диагностический анализ исследования алгоритмов обучения нейронных сетей "с учителем"

1.1 Сбор данных для нейронной сети

1.2 Пре/пост процессирование

.3 Обучение многослойного персептрона

.4 Алгоритм обратного распространения

.5 Переобучение и обобщение

.6 Как обучается многослойный персептрон

2. Реализация алгоритмов обучения нейронных сетей "с учителем"

Заключение

Список использованных источников

Приложение

ВВЕДЕНИЕ

В последние несколько лет мы наблюдаем взрыв интереса к нейронным сетям <#"513407.files/image001.gif">

Рисунок 1.1. Поверхность отклика, полученная многослойным персептроном.

На рисунке показана поверхность отклика, полученная многослойным персептроном <http://www.statsoft.ru/home/textbook/glossary/gloss_m.html> для решения задачи исключающего или: хорошо видно, что она выделяет область пространства, расположенную вдоль диагонали.

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

Как следствие наших рассмотрений мы получаем, что, теоретически, для моделирования любой задачи достаточно многослойного персептрона <http://www.statsoft.ru/home/textbook/glossary/gloss_m.html> с двумя промежуточными слоями (в точной формулировке этот результат известен как теорема Колмогорова). При этом может оказаться и так, что для решения некоторой конкретной задачи более простой и удобной будет сеть с еще большим числом слоев. Однако, для решения большинства практических задач достаточно всего одного промежуточного слоя, два слоя применяются как резерв в особых случаях, а сети с тремя слоями практически не применяются.

В задачах классификации <http://www.statsoft.ru/home/textbook/glossary/gloss_k.html> очень важно понять, как следует интерпретировать те точки, которые попали на склон или лежат близко от него. Стандартный выход здесь состоит в том, чтобы для пороговых значений установить некоторые доверительные пределы <http://proxy/../glossary/gloss_d.html> (принятия или отвержения), которые должны быть достигнуты, чтобы данных элемент считался "принявшим решение". Например, если установлены пороги принятия/отвержения 0.95/0.05, то при уровне выходного сигнала, превосходящем 0.95 элемент считается активным, при уровне ниже 0.05 - неактивным, а в промежутке - "неопределенным".

Имеется и более тонкий (и, вероятно, более полезный) способ интерпретировать уровни выходного сигнала: считать их вероятностями. В этом случае сеть выдает несколько большую информацию, чем просто "да/нет": она сообщает нам, насколько (в некотором формальном смысле) мы можем доверять ее решению. Разработаны (и реализованы в пакете ST Neural Networks) модификации метода MLP, позволяющие интерпретировать выходной сигнал нейронной сети <http://www.statsoft.ru/home/textbook/glossary/gloss_n.html> как вероятность, в результате чего сеть по существу учится моделировать плотность вероятности распределения данного класса. При этом, однако, вероятностная интерпретация обоснована только в том случае, если выполнены определенные предположения относительно распределения исходных данных (конкретно, что они являются выборкой из некоторого распределения, принадлежащего к семейству экспоненциальных распределений <http://www.statsoft.ru/home/textbook/glossary/gloss_ae.html>; Bishop, 1995). Здесь, как и ранее, может быть принято решение по классификации <http://www.statsoft.ru/home/textbook/glossary/gloss_k.html>, но, кроме того, вероятностная интерпретация позволяет ввести концепцию "решения с минимальными затратами".

2. РЕАЛИЗАЦИЯ АЛГОРИТМОВ ОБУЧЕНИЯ НЕЙРОННЫХ СЕТЕЙ "С УЧИТЕЛЕМ"

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

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

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

Как видно из него, в классе NeuronUL в отличие от NeuronBP отсутствуют обратные связи и инструменты их поддержания, а по сравнению с NeuronFF здесь появилось лишь две новых переменных - delta и inhibitory. Первая из них хранит расстояние, рассчитываемое по формуле , а вторая - величину заторможенности нейрона. В классе NeuronUL существует два конструктора - один, используемый по умолчанию, - не имеет параметров, и к созданным с помощью него нейронам необходимо затем применять метод _allocateNeuron класса NeuronFF. Другой сам вызывает эту функцию через соответствующий конструктор NeuronFF. Метод Propagate является почти полным аналогом одноименного метода из NeuronFF, за исключением вычисления величин delta и inhibitory. Методы Normalize и Equalize выполняют соответственно нормализацию значений весовых коэффициентов по формуле. Метод CountDistance вычисляет расстояние. Следует особо отметить, что в классе отсутствует метод IsConverged, что, объясняется, как говорилось выше, различными способами определения факта завершения обучения. Хотя в принципе написать такую функцию не сложно, в данной программной реализации завершение обучения определяется по "телеметрической" информации, выводимой на экран, самим пользователем. В представленном же вместе со статьей тесте число итераций, выполняющих обучение, вообще говоря, эмпирически задано равным 3000.

В состав класса LayerUL входит массив нейронов neurons и переменная с размерностью массивов синапсов - neuronrang. Метод распределения нейронов - внешний или внутренний - определяется тем, как создавался слой. Этот признак хранится в переменной allocation. Конструктор LayerUL(unsigned, unsigned) сам распределяет память под нейроны, что соответствует внутренней инициализации; конструктор LayerUL(NeuronUL _FAR *, unsigned, unsigned) создает слой из уже готового, внешнего массива нейронов. Все методы этого класса аналогичны соответствующим методам класса LayerFF и, в большинстве своем, используют одноименные методы класса NeuronUL.

В классе NetUL также особое внимание необходимо уделить конструкторам. Один из них - NetUL(unsigned n) создает сеть из n пустых слоев, которые затем необходимо заполнить с помощью метода SetLayer. Конструктор NetUL(unsigned n, unsigned n1, ...) не только создает сеть из n слоев, но и распределяет для них соответствующее число нейронов с синапсами, обеспечивающими полносвязность сети. После создания сети необходимо связать все нейроны с помощью метода FullConnect. Как и в случае сети обратного распространения, сеть можно сохранять и загружать в/из файла с помощью методов SaveToFile, LoadFromFile. Из всех остальных методов класса новыми по сути являются лишь NormalizeNetInputs и ConvexCombination. Первый из них нормализует входные вектора, а второй реализует преобразование выпуклой комбинации.

В конце заголовочного файла описаны глобальные функции. SetSigmoidTypeUL, SetSigmoidAlfaUL и SetDSigmaUL аналогичны одноименным функциям для сети обратного распространения. Функция SetAccreditationUL устанавливает режим, при котором эффективность обучения нейронов, попавших в окружение наиболее возбужденного на данной итерации нейрона, пропорциональна функции Гаусса от расстояния до центра области обучения. Если этот режим не включен, то все нейроны попавшие в область с текущим радиусом обучения одинаково быстро подстраивают свои синапсы, причем область является квадратом со стороной, равной радиусу обучения. Функция SetLearnRateUL устанавливает коэффициент скорости обучения, а SetMaxDistanceUL - радиус обучения. Когда он равен 0 - обучается только один нейрон. Функции SetInhibitionUL и SetInhibitionFresholdUL устанавливают соответственно длительность торможения и величину возбуждения, его вызывающего.

Тексты функций помещены в файле neuro_mm.cpp, представленном в листинге 2. Кроме него в проект тестовой программы входят также модули neuron_ff.cpp и subfun.cpp. Главный модуль, neuman7.cpp приведен в листинге 3. Программа компилировалась с помощью компилятора Borland C++ 3.1 в модели LARGE.

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

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

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

ЗАКЛЮЧЕНИЕ

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

Серия работ М. Г. Доррера с соавторами посвящена исследованию вопроса о возможности развития психологической интуиции <http://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D1%83%D0%B8%D1%86%D0%B8%D1%8F> у нейросетевых экспертных систем <http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%B5%D1%80%D1%82%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0>. Полученные результаты дают подход к раскрытию механизма интуиции нейронных сетей, проявляющейся при решении ими психодиагностических задач. Создан нестандартный для компьютерных методик интуитивный подход к психодиагностике <http://ru.wikipedia.org/wiki/%D0%9F%D1%81%D0%B8%D1%85%D0%BE%D0%B4%D0%B8%D0%B0%D0%B3%D0%BD%D0%BE%D1%81%D1%82%D0%B8%D0%BA%D0%B0>, заключающийся в исключении построения описанной реальности. Он позволяет сократить и упростить работу над психодиагностическими методиками.

Нейронные сети широко используются в химических и биохимических исследованиях. В настоящее время нейронные сети являются одним из самых распространенных методов хемоинформатики <http://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D0%BC%D0%BE%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0> для поиска количественных соотношений структура-свойство <http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BA%D0%BE%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D0%BE%D1%82%D0%BD%D0%BE%D1%88%D0%B5%D0%BD%D0%B8%D0%B9_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0-%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%BE>, благодаря чему они активно используются как для прогнозирования физико-химических свойств и биологической активности химических соединений, так и для направленного дизайна химических соединений и материалов с заранее заданными свойствами, в том числе при разработке новых лекарственных препаратов.

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1. Стюарт Рассел, Питер Норвиг Искусственный интеллект: современный подход (Artificial Intelligence: A Modern Approach). 2-е издание. Вильямс, 2006 г.

. Тархов Д.А. Нейронные сети. Модели и алгоритмы. Радиотехника, 2005 г.

3.       Рутковская.Д. Нейронные сети, генетические алгоритмы и нечёткие системы, Горячая линия-Телеком, 2004 г.

.        Усков А.А., Кузьмин А.В. Интеллектуальные технологии управления. Искусственные нейронные сети и нечеткая логика, Горячая линия-Телеком,2004 г.

5. Иванов А.И. Нейросетевые алгоритмы биометрической идентификации- Радиотехника, 2004 г.

6.       С.Хайкин <http://www.ozon.ru/context/detail/id/2476937/?partner=neuroproject>, Нейронные сети: полный курс. 2-е изд. М., "Вильямс", 2006. <http://www.ozon.ru/context/detail/id/2476937/?partner=neuroproject>

7. Л.Г.Комарцова, А.В.Максимов. Нейрокомпьютеры. М., Изд-во МГТУ им. Баумана, 2002 г.

. Круглов, Борисов - Искусственные нейронные сети. Теория и практика, 2002 г.

9.       В.А.Головко. Нейронные сети: обучение, организация и применение. М., ИПРЖР, 2001 г. <http://www.ozon.ru/context/detail/id/1307273/?partner=neuroproject>

.        В.А.Головко. Нейронные сети: обучение, организация и применение. М., ИПРЖР, 2001 г. <http://www.ozon.ru/context/detail/id/1307273/?partner=neuroproject>

ПРИЛОЖЕНИЕ

Листинг 1. Фрагмент заголовочного файла с описаниями классов и функций

// FILE neuro_mm.h

#include "neuro.h" // описание базовых классов

class LayerUL;NetUL;NeuronUL: public NeuronFF

{ friend LayerUL;NetUL;delta;inhibitory;:(unsigned num_inputs);(void){delta=0.;};

~NeuronUL();

// int IsConverged(void); // можно реализоватьvoid Propagate(void);Equalize(void);Normalize(void);CountDistance(void);SetInhibitory(unsigned in){inhibitory=in;};GetInhibitory(void){return inhibitory;};

};LayerUL: public LayerFF

{ friend NetUL;_FAR *neurons;neuronrang;allocation;imax, imaxprevious1;:(unsigned nRang, unsigned nSinapses);(NeuronUL _FAR *Neu, unsigned nRang,nSinapses);(void)

{=NULL; neuronrang=0; allocation=EXTERN;=imaxprevious1=-1;

};

~LayerUL();Propagate(void);Randomize(float);Normalize(void);NormalizeSynapses(void);Equalize(void);void Show(void);void DigiShow(void);void PrintSynapses(int,int);void PrintAxons(int x, int y, int direction);TranslateAxons(void);*GetNeuron(unsigned n)

{(neurons && (n< f); SetInhibitionFreshold(float float in); SetInhibitionUL(int void md); SetMaxDistanceUL(float ac); SetAccreditationUL(int d); SetDSigmaUL(unsigned unsigned lr); SetLearnRateUL(float Al); SetSigmoidAlfaUL(float st); SetSigmoidTypeUL(int int }; **Net); Reverse(NetUL step); *In, ConvexCombination(float *mv); _FAR NormalizeNetInputs(float AddNoise(void); In); Change(float virtual x="0,...){};" PrintSynapses(int l){learncycle="l;};" SetLearnCycle(unsigned *IN); LoadNextPattern(float *file); char LoadFromFile(unsigned SaveToFile(unsigned Equalize(void); NormalizeSynapses(void); Normalize(void); Randomize(float); Learn(void); *mvalue); SetNetInputs(float Propagate(void); FullConnect(void); } NULL; return else layers[n]; {if(n

Листинг 2. Тексты функций помещены в файле neuro_mm.cpp

// FILE neuro_mm.cpp FOR neuro_mm.prj

#include

#include

#include

#include

#include

#include

#include "neuro_mm.h"

#define MAXDISTANCE MAXFLOATint SigmoidType=ORIGINAL;int Accreditation=0;float SigmoidAlfa=1.;float LearnRate=0.25;unsigned dSigma=0;float MaxDistance=MAXDISTANCE;int Inhibition=0;float InFreshold=0.0;SetSigmoidTypeUL(int st)

{i;=SigmoidType;=st;i;

}SetAccreditationUL(int ac)

{=ac;

}

// число циклов на которые нейрон тормозится

// после возбужденияSetInhibitionUL(int in)

{=in;

}

// порог возбуждения, инициирующий торможение

float SetInhibitionFreshold(float f)

{a;=InFreshold;=f;a;

}SetSigmoidAlfaUL(float Al)

{a;=SigmoidAlfa;=Al;a;

}SetMaxDistanceUL(float md)

{a;=MaxDistance;(md<1.0) Accreditation=0;=md;a;

}SetLearnRateUL(float lr)

{a;=LearnRate;=lr;a;

}SetDSigmaUL(unsigned d)

{u;=dSigma;=d;u;

}::~NeuronUL()

{

// dummy

}::NeuronUL(unsigned num_inputs)

:NeuronFF(num_inputs)

{=0.; inhibitory=0;

}NeuronUL::Propagate(void)

{=0.;(unsigned i=0;iInFreshold) // возбуждение

{(inhibitory<=0) // пока не заторможен=axon*Inhibition/0.5; // тормозим

}

// постепенное восстановление возможности возбуждаться(inhibitory>0) inhibitory--;

}NeuronUL::Equalize(void)

{sq=1./sqrt(rang);(int i=0;i=5) n=4;(j*dx+i/2=100) n=99;(cc,"%02d",n);(j*dx+i/2=70) a=CGRAY;if(n>=50) a=CCYAN;if(n>=30) a=CBLUE;a=0;(i%2==0)_char(x+1+i, y+1+j, cc[0], 15 | a);_char(x+1+i, y+1+j, cc[1], 15 | a);

}

}_char(x+1+i, y+1+j,GRAFCHAR_VERTICALLINE,15);

}_char(x,y+j+1,GRAFCHAR_BOTTOMLEFTCORNER,15);(i=0;i<2*dx;i++)_char(x+i+1,y+j+1,GRAFCHAR_HORIZONTALLINE,15);_char(x+1+i,y+j+1, GRAFCHAR_BOTTOMRIGHTCORNER,15);

}LayerUL::PrintSynapses(int x, int y)

{(unsigned i=0;i 0)

{(cy=max(ny-(int)MaxDistance,0);=1.0)[i].delta=(-sqrt((nx-x)*(nx-x)+(ny-y)*(ny-y))

/MaxDistance);Accreditation=0;

}

}

}::NetUL(unsigned nLayers)

{=NULL;(nLayers==0)

{=ERROR; return;

}=new LayerUL _FAR *[nLayers];(layers==NULL) status=ERROR;

{=nLayers;(unsigned i=0;i~LayerUL();[] layers; layers=NULL;

}

}

}NetUL::SetLayer(unsigned n, LayerUL _FAR * pl)

{i,p;(n>=rang) return 1;=pl->rang;(p==0) return 2;

if(n) // если не первый слой

{(layers[n-1]!=NULL)

// если предыдущий слой уже установлен,

{ // проверяем соответствие числа нейронов

// в нем и синапсов в добавляемом слое

for(i=0;irang)3;

}

}(nrang;i++)(p!=layers[n+1]->neurons[i].rang) return 4;

}[n]=pl;0;

}NetUL::FullConnect(void)

{*l;i,j,k,n;(i=1;irang==0) return 1;=(*layers[i-1]).rang;(n==0) return 2;(j=0;jrang;j++) // по нейронам

{(k=0;kneurons[j].inputs[k]=

&(layers[i-1]->neurons[k].axon);

}

}

}0;

}NetUL::Propagate(void)

{(unsigned i=1;iPropagate();

}

{(unsigned i=0;irang;i++)[0]->neurons[i].axon=mv[i];

}NetUL::NormalizeNetInputs(float _FAR *mv)

{s=0.;(unsigned i=0;irang;i++)+=(mv[i]+0.5)*(mv[i]+0.5);=sqrt(s);(s) for(i=0;irang;i++)[i]=(mv[i]+0.5)/s-0.5;

}Signum(float a, float b)

{(a<0 && b<0) return -1;(a>0 && b>0) return 1;0;

}LayerUL::TranslateAxons(void)

{(0==Accreditation) return;(int i=0;irang;i++)

{ // по нейронам(layers[j]->neurons[i].delta == 0) continue;(k=0;kneuronrang;k++)

// по синапсам

{[j]->neurons[i].synapses[k]+=LearnRate*

(layers[j-1]->neurons[k].axon

layers[j]->neurons[i].synapses[k]);

}

}

}

{(i=0;irang;i++)

{ // по нейронам(Inhibition // заторможенные пропускаем

&& layers[j]->neurons[i].inhibitory>0) continue;(k=0;kneuronrang;k++)

// по синапсам

{[j]->neurons[i].synapses[k]+=LearnRate

*layers[j]->neurons[i].delta

*(layers[j-1]->neurons[k].axon

layers[j]->neurons[i].synapses[k]);

}

}

}

}

}NetUL::Randomize(float range)

{(unsigned i=0;iRandomize(range);

}NetUL::Equalize(void)

{(unsigned i=1;iEqualize();

}NetUL::Normalize(void)

{(unsigned i=1;iNormalize();

}NetUL::SaveToFile(unsigned char *file)

{*fp;=fopen(file,"wt");(fp==NULL) return 1;(fp,"%u",rang);(unsigned i=0;irang);(fp,"\n¦%u",layers[i]->neuronrang);(unsigned j=0;jrang;j++)

{(fp,"\n¦+%f",layers[i]->neurons[j].state);(fp,"\n¦¦%f",layers[i]->neurons[j].axon);(fp,"\n¦¦%f",layers[i]->neurons[j].delta);(unsigned k=0;kneuronrang;k++)

{(fp,"\n¦¦%f",[i]->neurons[j].synapses[k]);

}(fp,"\n¦+");

}(fp,"\n+");

}(fp);0;

}NetUL::LoadFromFile(unsigned char *file)

{*fp;i,r,nr;char bf[12];=fopen(file,"rt");(fp==NULL) return 1;(fp,"%u\n",&r);(r==0) goto allerr;=new LayerUL _FAR *[r];(layers==NULL)

{ allerr: status=ERROR; fclose(fp); return 2; }

{=r;(i=0;irang;j++)

{(fp,"¦+%f\n",&(layers[i]->neurons[j].state));(fp,"¦¦%f\n",&(layers[i]->neurons[j].axon));(fp,"¦¦%f\n",&(layers[i]->neurons[j].delta));(unsigned k=0;kneuronrang;k++)

{(fp,"¦¦%f\n",

&(layers[i]->neurons[j].synapses[k]));

}(bf,10,fp);

}(bf,10,fp);

}(fp);0;

}::NetUL(unsigned n, unsigned n1, ...)

{i, num, prenum;_list varlist;=OK; rang=0; pf=NULL; learncycle=0;layers=NULL;=new LayerUL _FAR *[n];(layers==NULL) { allerr: status=ERROR; }

{=n;(i=0;iGetStatus()==ERROR) status=ERROR;_start(varlist,n1);(i=1;iGetStatus()==ERROR) status=ERROR;

}_end(varlist);

}

}NetUL::LoadNextPattern(float _FAR *IN)

{char buf[256];char *s, *ps;i;(imgfile==1)

{:(i=0;idy;i++)

{(fgets(buf,256,pf)==NULL)

{(learncycle)

{(pf);-;restart;

}return 2;

}(int j=0;jdx;j++)

{(buf[j]=='x') IN[i*layers[0]->dx+j]=0.5;if(buf[j]=='.') IN[i*layers[0]->dx+j]=-0.5;

}

}(buf,256,pf);0;

}if(imgfile==2 && emuf != NULL)(*emuf)(layers[0]->rang,IN,NULL);if(pf==NULL) return 1;

// разбор строки доверять функции scanf нельзя

start:(fgets(buf,250,pf)==NULL)

{(learncycle)

}return 2;

}=buf;(;*s==' ';s++);(i=0;irang;i++)

{=strchr(s,' ');(ps) *ps=0;[i]=atof(s);=ps+1; for(;*s==' ';s++);

}(buf,256,pf);0;

}

// функция внесения помехNetUL::Change(float In)

{-In;

}NetUL::AddNoise(void)

{i,k;(i=0;irang);[0]->neurons[k].axon=(layers[0]->neurons[k].axon);

}

}NetUL::ConvexCombination(float *In, float step)

{sq=1./sqrt(layers[0]->rang)-0.5;(step<0.) step=0.;(step>1.) step=1.;(int i=0;irang;i++)[i]=In[i]*step+sq*(1-step);

}NetUL::NormalizeSynapses(void)

{(unsigned i=0;iNormalizeSynapses();

}

Листинг 3. Главный модуль, neuman7.cpp

// FILE neuman7.cpp for neuro_mm.prj

#include

#include

#include

#include

#include

#include "neuro_mm.h"

//#define INHIBITION 2

#pragma argsusedGenFunction(int n, float _FAR *in, float _FAR *ou)

{unsigned loop=0;int repeat=0;i;(i=0;iSetName("Input");.GetLayer(0)->SetShowDim(1,1,2,1);.GetLayer(1)->SetName("Out");

N.GetLayer(1)->SetShowDim(17,1,10,10);(2); // задаем начальное условие для ГСЧ

SetSigmoidTypeUL(HYPERTAN);(2);.FullConnect();.Randomize(5);.NormalizeSynapses();

// N.Equalize(); // использовать с ConvexCombination.SetLearnCycle(64000U);(1);

// используем гауссиан для определения формы

// области обучения и эффективности воздействия(1);

// SetInhibitionUL(INHIBITION);.EmulatePatternFile(GenFunction);=13;(count=0;;count++)

{(buf," Cycle %u ",count);_str(1,23,buf,10 | (1<<4));(buf,"MD=%.1f ",md);_str(14,23,buf,10);_str(1,24," ESC breaks ",11 | (1<<4));(kbhit() || i==13) i=getch();(i==27) break;(i=='s' || i=='S')

{_str(40,24,"FileConf:",7);(50,25);(buf);(strlen(buf)) N.SaveToFile(buf);;

}(N.LoadNextPattern(Inp)) break;

// использовать вместе NormalizeSynapses

// для сложных образов

// N.NormalizeNetInputs(Inp);(count<3000)=SetMaxDistanceUL(7.0*(3000-count)/3000+1);(0);(count<3000)(0.1*(3000-count)/3000+0.05);(0.1);

// N.ConvexCombination(Inp,(float)count/1000);

N.SetNetInputs(Inp);

// в случае ограниченного тренировочного набора

// варьируем выборку данных

// N.AddNoise();.Propagate();

// если нажат Shift, ничего не выводим

// для ускорения процесса(!(bioskey(2) & 0x03))

{.GetLayer(0)->DigiShow();.GetLayer(1)->DigiShow(); // состояние.GetLayer(1)->SetShowDim(50,1,10,10);.GetLayer(1)->TranslateAxons();

N.GetLayer(1)->Show(); // текущая область обучения

N.GetLayer(1)->SetShowDim(17,1,10,10);

}

// N.NormalizeSynapses();.Learn();

}.ClosePatternFile();0;

}