Как создать нейронные сети?

// FILE neuro_mm.h
#include "neuro.h" // описание базовых классов
 
class LayerUL;
class NetUL;
 
class NeuronUL: public NeuronFF
{                                friend LayerUL;
                                 friend NetUL;
 float delta;
 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<rang)) return &neurons[n];
  else return NULL;
 };
};
 
class NetUL: public SomeNet
{
 LayerUL _FAR * _FAR *layers;
 // 1-й слой - входной, без синапсов
public:
 NetUL(void) {layers=NULL;};
 NetUL(unsigned nLayers);
 NetUL(unsigned n, unsigned n1, ...);
 ~NetUL();
 int SetLayer(unsigned n, LayerUL _FAR *pl);
 LayerUL *GetLayer(unsigned n)
  {if(n<rang) return layers[n]; else return NULL; }
 int FullConnect(void);
 void Propagate(void);
 void SetNetInputs(float _FAR *mvalue);
 void Learn(void);
 void Randomize(float);
 void Normalize(void);
 void NormalizeSynapses(void);
 void Equalize(void);
 int  SaveToFile(unsigned char *file);
 int  LoadFromFile(unsigned char *file);
 int  LoadNextPattern(float _FAR *IN);
 void SetLearnCycle(unsigned l){learncycle=l;};
 void virtual PrintSynapses(int x=0,...){};
 float virtual Change(float In);
 void AddNoise(void);
 void NormalizeNetInputs(float _FAR *mv);
 void ConvexCombination(float *In, float step);
 int  Reverse(NetUL **Net);
};
 
int SetSigmoidTypeUL(int st);
float SetSigmoidAlfaUL(float Al);
float SetLearnRateUL(float lr);
unsigned SetDSigmaUL(unsigned d);
void SetAccreditationUL(int ac);
float SetMaxDistanceUL(float md);
void SetInhibitionUL(int in);
float SetInhibitionFreshold(float f);

// FILE neuro_mm.cpp FOR neuro_mm.prj
#include <stdlib.h>
#include <alloc.h>
#include <math.h>
#include <string.h>
#include <stdarg.h>
#include <values.h>
 
#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;i<rang;i++)
  state+=(*inputs[i]*2)*(synapses[i]*2);
 // поправка на использование логики ±0.5
 state/=2;
 axon=Sigmoid();
 
 if(Inhibition==0) return;
 
 if(axon>InFreshold) // возбуждение
 {
  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<rang;i++) synapses[i]=sq-0.5;
}
 
void NeuronUL::Normalize(void)
{
float s=0;
 for(int i=0;i<rang;i++) s+=synapses[i]*synapses[i];
 s=sqrt(s);
 if(s) for(int i=0;i<rang;i++) synapses[i]/=s;
}
 
LayerUL::LayerUL(unsigned nRang, unsigned nSynapses)
{
 allocation=EXTERN; status=ERROR; neuronrang=0;
 if(nRang==0) return;
 neurons=new NeuronUL[nRang];
 if(neurons==NULL) return;
 for(unsigned i=0;i<nRang;i++)
 {
  neurons[i].InitNeuron(nSynapses);
  neurons[i].SetInhibitory(0.0);
  if(neurons[i].GetStatus()==ERROR)
  {
   status=ERROR;
   return;
  }
 }
 rang=nRang;
 neuronrang=nSynapses;
 allocation=INNER;
 name=NULL; status=OK;
 imax=/*-imaxprevious1=*/-1;
}
 
LayerUL::LayerUL(NeuronUL _FAR *Neu, unsigned nRang,
         unsigned nSynapses)
{
 neurons=NULL; neuronrang=0; allocation=EXTERN;
 for(unsigned i=0;i<nRang;i++)
  if(Neu[i].rang!=nSynapses) status=ERROR;
 if(status==OK)
 {
  neurons=Neu;
  rang=nRang;
  neuronrang=nSynapses;
  imax=/*-imaxprevious1=*/-1;
 }
}
 
LayerUL::~LayerUL(void)
{
 if(allocation==INNER)
 {
  if(neurons!=NULL)
  {
   for(unsigned i=0;i<rang;i++)
    neurons[i]._deallocate();
   delete [] neurons; neurons=NULL;
  }
 }
}
 
void LayerUL::Randomize(float range)
{
 for(unsigned i=0;i<rang;i++)
  neurons[i].Randomize(range);
}
 
void LayerUL::Equalize(void)
{
 for(unsigned i=0;i<rang;i++)
  neurons[i].Equalize();
}
 
void LayerUL::NormalizeSynapses(void)
{
 for(unsigned i=0;i<rang;i++)
  neurons[i].Normalize();
}
 
void LayerUL::Normalize(void)
{
float s=0.;
 for(unsigned i=0;i<rang;i++)
  s+=(neurons[i].axon+0.5)*(neurons[i].axon+0.5);
 s=sqrt(s);
 if(s) for(i=0;i<rang;i++)
  neurons[i].axon=(neurons[i].axon+0.5)/s-0.5;
}
 
void LayerUL::Show(void)
{
unsigned char sym[5]={GRAFCHAR_EMPTYBLACK, GRAFCHAR_DARKGRAY, GRAFCHAR_MIDDLEGRAY, GRAFCHAR_LIGHTGRAY, GRAFCHAR_SOLIDWHITE };
int i,j;
 if(y && name) for(i=0;i<strlen(name);i++)
  out_char(x+i,y-1,name[i],3);
 out_char(x,y,GRAFCHAR_UPPERLEFTCORNER,15);
 for(i=0;i<2*dx;i++)
  out_char(x+1+i,y,GRAFCHAR_HORIZONTALLINE,15);
 out_char(x+1+i,y,GRAFCHAR_UPPERRIGHTCORNER,15);
 
 for(j=0;j<dy;j++)
 {
  out_char(x,y+1+j,GRAFCHAR_VERTICALLINE,15);
  for(i=0;i<2*dx;i++)
  {
   int n=(int) ((neurons[j*dx+i/2].axon+0.4999)*5);
   if(n<0) n=0;
   if(n>=5) n=4;
   if(j*dx+i/2<rang)
    out_char(x+1+i, y+1+j, sym[n], 15);
  }
  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::DigiShow(void)
{
int i,j;
char cc[3];
 
 if(y && name) for(i=0;i<strlen(name);i++)
  out_char(x+i,y-1,name[i],3);
 
 out_char(x,y,GRAFCHAR_UPPERLEFTCORNER,15);
 for(i=0;i<2*dx;i++)
  out_char(x+1+i,y,GRAFCHAR_HORIZONTALLINE,15);
 out_char(x+1+i,y,GRAFCHAR_UPPERRIGHTCORNER,15);
 
 for(j=0;j<dy;j++)
 {
  out_char(x,y+1+j,GRAFCHAR_VERTICALLINE,15);
  for(i=0;i<2*dx;i++)
  {
   int n=(int) ((neurons[j*dx+i/2].axon+0.4999)*100);
   if(n<0) n=0;
   if(n>=100) n=99;
   sprintf(cc,"%02d",n);
 
   if(j*dx+i/2<rang)
   {
    int a;
    if(n>=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<rang;i++)
  neurons[i].PrintSynapses(x,y+i);
}
 
void LayerUL::PrintAxons(int x, int y, int direction)
{
 for(unsigned i=0;i<rang;i++)
  neurons[i].PrintAxons(x+8*i*direction,
                        y+i*(!direction));
}
 
float NeuronUL::CountDistance(void)
{
int i;
float s=0.0;
 for(i=0;i<rang;i++)
  s+=fabs(*inputs[i]-synapses[i]);
 delta=s;
 return delta;
}
 
void LayerUL::Propagate(void)
{
unsigned i,j;
float fmax, f;
int cx, cy, nx, ny;
 
 for(i=0;i<rang;i++)
  neurons[i].Propagate();
 
  fmax=MAXDISTANCE;
  imax=-1;
  for(i=0;i<rang;i++)
  {
   f=neurons[i].CountDistance();
   if(f<fmax)
   {
    fmax=f;
    imax=i;
   }
  }
 
  if(imax==-1)
  {
   out_str(0,13,"minD=???",10);
   return;
  }
 
  ny=imax/dx;   // вычисление координат X & Y
  nx=imax%dx;
 
  char buf[40];
  sprintf(buf,"minD=%d(%d,%d)",imax,nx,ny);
  out_str(0,13,buf,10);
 
  for(i=0;i<rang;i++) neurons[i].delta = 0;
 
 
 if(0==Accreditation) //neurons[imax].delta = 1;
 
 {
  for(cx=max(nx-(int)MaxDistance,0);
      cx<min(nx+(int)MaxDistance+1,dx);cx++)
  {
   if(dy > 0)
   {
    for(cy=max(ny-(int)MaxDistance,0);
        cy<min(ny+(int)MaxDistance+1,dy);cy++)
    {
     // нейрон в зоне обучения
     neurons[cy*dx+cx].delta = 1;
    }
   }
   else
   {
    neurons[cx].delta = 1;
   }
  }
 }
 
 else //if(Accreditation)
 {
  for(i=0;i<rang;i++)
  {
   int y=i/dx;
   int x=i%dx;
 
   if(fabs(MaxDistance)>=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<rang;i++) layers[i]=NULL;
 }
}
 
NetUL::~NetUL()
{
 if(rang)
 {
  if(layers!=NULL)
  {
   for(unsigned i=0;i<rang;i++) layers[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;i<p;i++)
   if((*pl).neurons[i].rang!=layers[n-1]->rang)
    return 3;
  }
 }
 
 if(n<rang-1) // если не последний слой
 {
  if(layers[n+1])
  for(i=0;i<layers[n+1]->rang;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;i<rang;i++)  // кроме входного слоя
 {
  l=layers[i];               // по слоям
  if(l->rang==0) return 1;
  n=(*layers[i-1]).rang;
  if(n==0) return 2;
  for(j=0;j<l->rang;j++)     // по нейронам
  {
   for(k=0;k<n;k++)          // по синапсам
   {
    l->neurons[j].inputs[k]=
     &(layers[i-1]->neurons[k].axon);
   }
  }
 }
 return 0;
}
 
void NetUL::Propagate(void)
{
 for(unsigned i=1;i<rang;i++)
 {
  layers[i]->Propagate();
 }
}
 
void NetUL::SetNetInputs(float _FAR *mv)
{
 for(unsigned i=0;i<layers[0]->rang;i++)
  layers[0]->neurons[i].axon=mv[i];
}
 
void NetUL::NormalizeNetInputs(float _FAR *mv)
{
float s=0.;
 for(unsigned i=0;i<layers[0]->rang;i++)
  s+=(mv[i]+0.5)*(mv[i]+0.5);
 s=sqrt(s);
 if(s) for(i=0;i<layers[0]->rang;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;i<rang;i++)
 {
  neurons[i].axon=neurons[i].delta-0.5;
 }
}
 
void NetUL::Learn(void)
{
int j;
unsigned i,k;
 
 for(j=1;j<rang;j++)                // по слоям
 {
  if(Accreditation==0)
  {
   for(i=0;i<layers[j]->rang;i++)
   {                                // по нейронам
    if(layers[j]->neurons[i].delta == 0) continue;
 
    for(k=0;k<layers[j]->neuronrang;k++)
                    // по синапсам
    {
     layers[j]->neurons[i].synapses[k]+=LearnRate*
     (layers[j-1]->neurons[k].axon
     - layers[j]->neurons[i].synapses[k]);
    }
   }
  }
  else
  {
   for(i=0;i<layers[j]->rang;i++)
   {                                 // по нейронам
    if(Inhibition       // заторможенные пропускаем
    && layers[j]->neurons[i].inhibitory>0) continue;
 
    for(k=0;k<layers[j]->neuronrang;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;i<rang;i++)
  layers[i]->Randomize(range);
}
 
void NetUL::Equalize(void)
{
 for(unsigned i=1;i<rang;i++)
  layers[i]->Equalize();
}
 
void NetUL::Normalize(void)
{
 for(unsigned i=1;i<rang;i++)
  layers[i]->Normalize();
}
 
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;i<rang;i++)
 {
  fprintf(fp,"\n+%u",layers[i]->rang);
  fprintf(fp,"\n¦%u",layers[i]->neuronrang);
  for(unsigned j=0;j<layers[i]->rang;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;k<layers[i]->neuronrang;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;i<rang;i++) layers[i]=NULL;
 }
 
 for(i=0;i<rang;i++)
 {
  fgets(bf,10,fp);
  r=atoi(bf+1);
  fgets(bf,10,fp);
  nr=atoi(bf+1);
  layers[i] = new LayerUL(r,nr);
  for(unsigned j=0;j<layers[i]->rang;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;k<layers[i]->neuronrang;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;i<rang;i++) layers[i]=NULL;
 
  num=n1;
  layers[0] = new LayerUL(num,0);
  if(layers[0]->GetStatus()==ERROR) status=ERROR;
  va_start(varlist,n1);
  for(i=1;i<rang;i++)
  {
   prenum=num;
   num=va_arg(varlist,unsigned);
   layers[i] = new LayerUL(num,prenum);
   if(layers[i]->GetStatus()==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;i<layers[0]->dy;i++)
  {
   if(fgets(buf,256,pf)==NULL)
   {
    if(learncycle)
    {
     rewind(pf);
     learncycle--;
     goto restart;
    }
    else return 2;
   }
 
   for(int j=0;j<layers[0]->dx;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;i<layers[0]->rang;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;i<dSigma;i++)
 {
  k=random(layers[0]->rang);
  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;i<layers[0]->rang;i++)
  In[i]=In[i]*step+sq*(1-step);
}
 
void NetUL::NormalizeSynapses(void)
{
 for(unsigned i=0;i<rang;i++)
  layers[i]->NormalizeSynapses();
}

// FILE neuman7.cpp for neuro_mm.prj
#include <string.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <bios.h>
#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;i<n;i++) in[i]=(float)rand()/RAND_MAX-0.5;
 repeat++;
 if(repeat==232)
 {
  repeat=0;
  loop++;
  srand(loop);
 }
 return 0;
}
 
main()
{
float Inp[30];
int count;
unsigned char buf[256];
float md=0.0;
int i;
 
 NetUL N(2,2,100);
 
 if(N.GetStatus()==ERROR)
 {
  printf("\nERROR: Net Can not Be Constructed!");
  return 1;
 }
 
 ClearScreen();
 N.GetLayer(0)->SetName("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;
}
 
Листинг 4
 
// FILE colour.h
 
// background colours
#define CBLUE (1<<4)
#define CGREEN (1<<5)
#define CRED (1<<6)
 
#define CCYAN (CGREEN|CBLUE)
#define CYELLOW (CGREEN|CRED)
#define CMAGENTA (CBLUE|CRED)
#define CBLACK 0
#define CGRAY (CGREEN|CBLUE|CRED)