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

unsigned inhibitory;

public:

NeuronUL(unsigned num_inputs);

NeuronUL(void){delta=0.;};

~NeuronUL();

// int IsConverged(void); // можно реализовать

virtual void Propagate(void);

void Equalize(void);

void Normalize(void);

float CountDistance(void);

void SetInhibitory(unsigned in){inhibitory=in;};

unsigned GetInhibitory(void){return inhibitory;};

};

class LayerUL: public LayerFF

{ friend NetUL;

NeuronUL _FAR *neurons;

unsigned neuronrang;

int allocation;

int imax, imaxprevious1;

public:

LayerUL(unsigned nRang, unsigned nSinapses);

LayerUL(NeuronUL _FAR *Neu, unsigned nRang,

unsigned nSinapses);

LayerUL(void)

{

neurons=NULL; neuronrang=0; allocation=EXTERN;

imax=imaxprevious1=-1;

};

~LayerUL();

void Propagate(void);

void Randomize(float);

void Normalize(void);

void NormalizeSynapses(void);

void Equalize(void);

virtual void Show(void);

virtual void DigiShow(void);

virtual void PrintSynapses(int,int);

virtual void PrintAxons(int x, int y, int direction);

void TranslateAxons(void);

NeuronUL *GetNeuron(unsigned n)

{

if(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"

#include "colour.h"

#define MAXDISTANCE MAXFLOAT

static int SigmoidType=ORIGINAL;

static int Accreditation=0;

static float SigmoidAlfa=1.;

static float LearnRate=0.25;

static unsigned dSigma=0;

static float MaxDistance=MAXDISTANCE;

static int Inhibition=0;

static float InFreshold=0.0;

int SetSigmoidTypeUL(int st)

{

int i;

i=SigmoidType;

SigmoidType=st;

return i;

}

void SetAccreditationUL(int ac)

{

Accreditation=ac;

}

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

// после возбуждения

void SetInhibitionUL(int in)

{

Inhibition=in;

}

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

float SetInhibitionFreshold(float f)

{

float a;

a=InFreshold;

InFreshold=f;

return a;

}

float SetSigmoidAlfaUL(float Al)

{

float a;

a=SigmoidAlfa;

SigmoidAlfa=Al;

return a;

}

float SetMaxDistanceUL(float md)

{

float a;

a=MaxDistance;

if(md<1.0) Accreditation=0;

MaxDistance=md;

return a;

}

float SetLearnRateUL(float lr)

{

float a;

a=LearnRate;

LearnRate=lr;

return a;

}

unsigned SetDSigmaUL(unsigned d)

{

unsigned u;

u=dSigma;

dSigma=d;

return u;

}

NeuronUL::~NeuronUL()

{

// dummy

}

NeuronUL::NeuronUL(unsigned num_inputs)

:NeuronFF(num_inputs)

{

delta=0.; inhibitory=0;

}

void NeuronUL::Propagate(void)

{

state=0.;

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

{

if(inhibitory<=0) // пока не заторможен

inhibitory=axon*Inhibition/0.5; // тормозим

}

// постепенное восстановление возможности возбуждаться

if(inhibitory>0) inhibitory--;

}

void NeuronUL::Equalize(void)

{

float sq=1./sqrt(rang);

for(int i=0;i=5) n=4;

if(j*dx+i/2=100) n=99;

sprintf(cc,"%02d",n);

if(j*dx+i/2=70) a=CGRAY;

else if(n>=50) a=CCYAN;

else if(n>=30) a=CBLUE;

else a=0;

if(i%2==0)

out_char(x+1+i, y+1+j, cc[0], 15 | a);

else

out_char(x+1+i, y+1+j, cc[1], 15 | a);

}

}

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

}

out_char(x,y+j+1,GRAFCHAR_BOTTOMLEFTCORNER,15);

for(i=0;i<2*dx;i++)

out_char(x+i+1,y+j+1,GRAFCHAR_HORIZONTALLINE,15);

out_char(x+1+i,y+j+1, GRAFCHAR_BOTTOMRIGHTCORNER,15);

}

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

{

for(unsigned i=0;i 0)

{

for(cy=max(ny-(int)MaxDistance,0);

cy=1.0)

neurons[i].delta=

exp(-sqrt((nx-x)*(nx-x)+(ny-y)*(ny-y))

/MaxDistance);

else Accreditation=0;

}

}

}

NetUL::NetUL(unsigned nLayers)

{

layers=NULL;

if(nLayers==0)

{

status=ERROR; return;

}

layers=new LayerUL _FAR *[nLayers];

if(layers==NULL) status=ERROR;

else

{

rang=nLayers;

for(unsigned i=0;i~LayerUL();

delete [] layers; layers=NULL;

}

}

}

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

{

unsigned i,p;

if(n>=rang) return 1;

p=pl->rang;

if(p==0) return 2;

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

{

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

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

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

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

for(i=0;irang)

return 3;

}

}

if(nrang;i++)

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

}

layers[n]=pl;

return 0;

}

int NetUL::FullConnect(void)

{

LayerUL *l;

unsigned i,j,k,n;

for(i=1;irang==0) return 1;

n=(*layers[i-1]).rang;

if(n==0) return 2;

for(j=0;jrang;j++) // по нейронам

{

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

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

}

}

}

return 0;

}

void NetUL::Propagate(void)

{

for(unsigned i=1;iPropagate();

}

}

void NetUL::SetNetInputs(float _FAR *mv)

{

for(unsigned i=0;irang;i++)

layers[0]->neurons[i].axon=mv[i];

}

void NetUL::NormalizeNetInputs(float _FAR *mv)

{

float s=0.;

for(unsigned i=0;irang;i++)

s+=(mv[i]+0.5)*(mv[i]+0.5);

s=sqrt(s);

if(s) for(i=0;irang;i++)

mv[i]=(mv[i]+0.5)/s-0.5;

}

int Signum(float a, float b)

{

if(a<0 && b<0) return -1;

if(a>0 && b>0) return 1;

return 0;

}

void LayerUL::TranslateAxons(void)

{

if(0==Accreditation) return;

for(int i=0;irang;i++)

{ // по нейронам

if(layers[j]->neurons[i].delta == 0) continue;

for(k=0;kneuronrang;k++)

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

{

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

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

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

}

}

}

else

{

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

{ // по нейронам

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

&& layers[j]->neurons[i].inhibitory>0) continue;

for(k=0;kneuronrang;k++)

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

{

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

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

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

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

}

}

}

}

}

void NetUL::Randomize(float range)

{

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

}

void NetUL::Equalize(void)

{

for(unsigned i=1;iEqualize();

}

void NetUL::Normalize(void)

{

for(unsigned i=1;iNormalize();

}

int NetUL::SaveToFile(unsigned char *file)

{

FILE *fp;

fp=fopen(file,"wt");

if(fp==NULL) return 1;

fprintf(fp,"%u",rang);

for(unsigned i=0;irang);

fprintf(fp,"\n¦%u",layers[i]->neuronrang);

for(unsigned j=0;jrang;j++)

{

fprintf(fp,"\n¦+%f",layers[i]->neurons[j].state);

fprintf(fp,"\n¦¦%f",layers[i]->neurons[j].axon);

fprintf(fp,"\n¦¦%f",layers[i]->neurons[j].delta);

for(unsigned k=0;kneuronrang;k++)

{

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

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

}

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

}

fprintf(fp,"\n+");

}

fclose(fp);

return 0;

}

int NetUL::LoadFromFile(unsigned char *file)

{

FILE *fp;

unsigned i,r,nr;

unsigned char bf[12];

fp=fopen(file,"rt");

if(fp==NULL) return 1;

fscanf(fp,"%u\n",&r);

if(r==0) goto allerr;

layers=new LayerUL _FAR *[r];

if(layers==NULL)

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

else

{

rang=r;

for(i=0;irang;j++)

{

fscanf(fp,"¦+%f\n",&(layers[i]->neurons[j].state));

fscanf(fp,"¦¦%f\n",&(layers[i]->neurons[j].axon));

fscanf(fp,"¦¦%f\n",&(layers[i]->neurons[j].delta));

for(unsigned k=0;kneuronrang;k++)

{

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

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

}

fgets(bf,10,fp);

}

fgets(bf,10,fp);

}

fclose(fp);

return 0;

}

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

{

unsigned i, num, prenum;

va_list varlist;

status=OK; rang=0; pf=NULL; learncycle=0;layers=NULL;

layers=new LayerUL _FAR *[n];

if(layers==NULL) { allerr: status=ERROR; }

else

{

rang=n;

for(i=0;iGetStatus()==ERROR) status=ERROR;

va_start(varlist,n1);

for(i=1;iGetStatus()==ERROR) status=ERROR;

}

va_end(varlist);

}

}

int NetUL::LoadNextPattern(float _FAR *IN)

{

unsigned char buf[256];

unsigned char *s, *ps;

int i;

if(imgfile==1)

{

restart:

for(i=0;idy;i++)

{

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

{

if(learncycle)

{

rewind(pf);

learncycle--;

goto restart;

}

else return 2;

}

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

{

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

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

}

}

fgets(buf,256,pf);

return 0;

}

else if(imgfile==2 && emuf != NULL)

return (*emuf)(layers[0]->rang,IN,NULL);

else if(pf==NULL) return 1;

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

start:

if(fgets(buf,250,pf)==NULL)

{

if(learncycle)

{

rewind(pf);

learncycle--;

goto start;

}

else return 2;

}

s=buf;

for(;*s==' ';s++);

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

{

ps=strchr(s,' ');

if(ps) *ps=0;

IN[i]=atof(s);

s=ps+1; for(;*s==' ';s++);

}

fgets(buf,256,pf);

return 0;

}

// функция внесения помех

float NetUL::Change(float In)

{

return -In;

}

void NetUL::AddNoise(void)

{

unsigned i,k;

for(i=0;irang);

layers[0]->neurons[k].axon=

Change(layers[0]->neurons[k].axon);

}

}

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

{

float sq=1./sqrt(layers[0]->rang)-0.5;

if(step<0.) step=0.;

if(step>1.) step=1.;

for(int i=0;irang;i++)

In[i]=In[i]*step+sq*(1-step);

}

void NetUL::NormalizeSynapses(void)

{

for(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 argsused

int GenFunction(int n, float _FAR *in, float _FAR *ou)

{

static unsigned loop=0;

static int repeat=0;

int i;

for(i=0;iSetName("Input");

N.GetLayer(0)->SetShowDim(1,1,2,1);

N.GetLayer(1)->SetName("Out");

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

srand(2); // задаем начальное условие для ГСЧ

SetSigmoidTypeUL(HYPERTAN);

SetDSigmaUL(2);

N.FullConnect();

N.Randomize(5);

N.NormalizeSynapses();

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

N.SetLearnCycle(64000U);

SetLearnRateUL(1);

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

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

SetAccreditationUL(1);

// SetInhibitionUL(INHIBITION);

N.EmulatePatternFile(GenFunction);

i=13;

for(count=0;;count++)

{

sprintf(buf," Cycle %u ",count);

out_str(1,23,buf,10 | (1<<4));

sprintf(buf,"MD=%.1f ",md);

out_str(14,23,buf,10);

out_str(1,24," ESC breaks ",11 | (1<<4));

if(kbhit() || i==13) i=getch();

if(i==27) break;

if(i=='s' || i=='S')

{

out_str(40,24,"FileConf:",7);

gotoxy(50,25);

gets(buf);

if(strlen(buf)) N.SaveToFile(buf);

break;

}

if(N.LoadNextPattern(Inp)) break;

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

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

// N.NormalizeNetInputs(Inp);

if(count<3000)

md=SetMaxDistanceUL(7.0*(3000-count)/3000+1);

else

SetMaxDistanceUL(0);

if(count<3000)

SetLearnRateUL(0.1*(3000-count)/3000+0.05);

else

SetLearnRateUL(0.1);

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

N.SetNetInputs(Inp);

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

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

// N.AddNoise();

N.Propagate();

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

// для ускорения процесса

if(!(bioskey(2) & 0x03))

{

N.GetLayer(0)->DigiShow();

N.GetLayer(1)->DigiShow(); // состояние

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

N.GetLayer(1)->TranslateAxons();

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

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

}

// N.NormalizeSynapses();

N.Learn();

}

N.ClosePatternFile();

return 0;

}

Размещено на Allbest.ru