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

Дипломная работа - Компьютеры, программирование

Другие дипломы по предмету Компьютеры, программирование



ы в файле 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 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,"d",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();

}

}NetUL::SetNetInputs(float _FAR *mv)

{(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)

{(a0) 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)

{(pf);-;start;

}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;(step1.) 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);

// в случае ограниченно?/p>