art2.cpp

adaptive resonance theory 2 人工神经网络

	  i += valid;
	}
	else
		i++;
  }
  return count;
}

aka *interpret_assignment(char *s)
{
  aka *result;
  int i,eqflag = 0;
  result = (aka *)calloc(1,sizeof(aka));
  for(i=1; (i<strlen(s)-1) && !eqflag; i++)
  {
    if(s[i] == '=') 
		eqflag = i;
	if((s[i] > ' ') && !eqflag)
		result->c = s[i];
  }
  if(is_float((char *)&s[eqflag+1]))
	  result->v = (float) atof ((char *)&s[eqflag+1]);
  else
	  result->v = 0;
  return result;
}

float *interpret_pattern(char *s,int *dim)
{
	int i,index;
	float *result;
	if( *dim < 0 ) 
		*dim = dimension(s);
	else
		if(*dim != dimension(s))
		{
			printf("\nERROR:pattern\"%s\"dimension different than previous examples.",s);
			exit (0);
		}
	result = (float *)calloc (*dim, sizeof(float));
	for (i=0,index=1; i<*dim; i++)
		index += translate ((char *)&s[index],&result[i]);
	return result;
}

int read_statement(FILE *fp,char *result)
{
  char c=' ';
  int i,sflag = 1;
  while(!(feof(fp)) && (c != '{'))
	  c = fgetc(fp);
  for(i=0;(c != '}') && (!feof(fp));)
  {
    if(position(c,"\n\t") < 0)
	{
	  result[i++] = toupper(c);
	  sflag = 1;
	}
	else
	{
	  if((c == ' ') && sflag)
	  {
         result[i++] = c;
		 sflag = 0; 
	  }
	}
	c = fgetc(fp);
  }
  result[i++] = c;
  result[i] = '\0';
  return (c == '}');
}

int extract(char *s, char *invec, char *outvec)
{
  int i,j,len;
  char c=' ';
  len = strlen(s);
  for(i=0;(c != '(') && (i < len); i++)
	  c = s[i];
  for(i=0;(c != ')') && (i < len); i++,j++)
  {
    invec[j] = c;
	c = s[i];
  }
  invec[j++] = c;
  invec[j] = '\0';
  for(;(c != '(') && ( i<len); i++)
	  c = s[i];
  for(i=0;(c != ')') && (i < len); i++,j++)
  {
    outvec[j] = c;
	c = s[i];
  }
  outvec[j++] = c;
  outvec[j] = '\0';
  return (i <= len);
}

int interpret(char *s,float **inval,float **outval, int *dX,int *dY)
{
  char invec[2048],outvec[2048];
  if(is_assignment(s))
  {
    alias[akacnt++] = interpret_assignment(s);
	return 0;
  }
  if(extract(s,(char *)&invec, (char *)&outvec))
  {
    *inval = interpret_pattern(invec,dX);
	*outval = interpret_pattern(outvec,dY);
	return 1;
  }
  return 0;
}

int init_patterns(FILE *fp)
{
  int i=0;
  char buffer[4096],*s = (char *)&buffer[0];
  alias = (aka **)calloc(MAX_ALIASES,sizeof(aka *));
  akacnt = 0;
  while(!(feof(fp)) && (read_statement(fp,s)))
	  if(!(is_assignment(s)) && (position('(',s)>=0))
		  i++;
  rewind(fp);
  return i;
}

int load_exemplars(char *filename,iop *pattern)
{
  FILE *fp;
  char buffer[4096],*s = (char *)&buffer[0];
  int iopairs=0, how_many;
  float **invecs,**outvecs;
  if(!(fp = fopen(filename, "r")))
  {
    printf("\nError:Coule not open exemplar file \"%d\"", filename);
	exit (0);
  }
  how_many = init_patterns(fp);
  pattern->invecs = (float **) calloc (how_many,sizeof(float *));
  pattern->outvecs = (float **) calloc (how_many,sizeof(float *));
  while(!(feof(fp)) && (read_statement(fp,s)))
  {
    if(interpret(s,&pattern->invecs[iopairs],&pattern->outvecs[iopairs],&pattern->dimX,&pattern->dimY))
		iopairs++;
	if(akacnt >= MAX_ALIASES)
	{
	  printf("\nError: Too many assignment statements in exemplar file.");
	  fclose(fp);
	  exit(0);
	}
  }
  fclose(fp);
  return (iopairs);
}

art2 *build_art2(int *sizes)
{
  art2 *n;
  int i,layers;
  n = (art2 *) calloc (1, sizeof(art2));
  layers = sizes[0] + 1;
  sizes[0] = sizes[1]; //Input layer will be same size as F1
  n->net = build_net(layers,sizes);
  n->layers = layers;
  n->f1.w = (float *) calloc (sizes[1],sizeof(float));
  n->f1.x = (float *) calloc (sizes[1],sizeof(float));
  n->f1.v = (float *) calloc (sizes[1],sizeof(float));
  n->f1.u = (float *) calloc (sizes[1],sizeof(float));
  n->f1.p = (float *) calloc (sizes[1],sizeof(float));
  n->f1.q = (float *) calloc (sizes[1],sizeof(float));
  n->f1.r = (float *) calloc (sizes[1],sizeof(float));
  n->patterns = (iop *) calloc (1,sizeof(iop));
  n->patterns->dimX = -1; //no exemplars yet
  n->patterns->dimY = -1;
  n->patterns->invecs = NULL;
  n->patterns->outvecs = NULL;
  n->exemplars = 0;
  strcpy(n->filename,"");
  free(sizes);
  return n;
}

void destroy_art2(art2 *n)
{
  int i;
  for(i=0;i<n->exemplars;i++)
  {
    if(n->patterns->invecs[i])
		free(n->patterns->invecs[i]);
	if(n->patterns->outvecs[i])
		free(n->patterns->outvecs[i]);
  }
  if(n->f1.w) free(n->f1.w);
  if(n->f1.x) free(n->f1.x);
  if(n->f1.v) free(n->f1.v);
  if(n->f1.u) free(n->f1.u);
  if(n->f1.p) free(n->f1.p);
  if(n->f1.q) free(n->f1.q);
  if(n->f1.r) free(n->f1.r);
  if(n->errs) free(n->errs);
  if(n->patterns->invecs) free(n->patterns->invecs);
  if(n->patterns->outvecs) free(n->patterns->outvecs);
  destroy_net(n->layers,n->net);
  free(n);
}

void show_net(art2 *n)
{
  int i;
  float *l;
  printf("\nW: ");
  for(i=0,l=n->f1.w; i<F1->units; i++)
	  printf("%7.3f ",l[i]);
  printf("\nX: ");
  for(i=0,l=n->f1.x; i<F1->units; i++)
	  printf("%7.3f ",l[i]);
  printf("\nV: ");
  for(i=0,l=n->f1.v; i<F1->units; i++)
	  printf("%7.3f ",l[i]);  printf("\nW: ");
  printf("\nU: ");
  for(i=0,l=n->f1.u; i<F1->units; i++)
	  printf("%7.3f ",l[i]);  printf("\nW: ");
  printf("\nP: ");
  for(i=0,l=n->f1.p; i<F1->units; i++)
	  printf("%7.3f ",l[i]);  printf("\nW: ");
  printf("\nQW: ");
  for(i=0,l=n->f1.q; i<F1->units; i++)
	  printf("%7.3f ",l[i]);  printf("\nW: ");
  printf("\nR: ");
  for(i=0,l=n->f1.r; i<F1->units; i++)
	  printf("%7.3f ",l[i]);  printf("\nW: ");
  printf("\n\n");
  for(i=0; i<n->layers; i++)
  {
    show_outputs(LAYER[i]);
	show_weights(LAYER[i]);
	printf("\n");
  }
  if(getch() == ' ')
	  exit(0);
}

float *get_invec(art2 *n,int pattern)
{
  if(n->patterns->invecs)
	  return (n->patterns->invecs[pattern]);
  else 
	  return (NULL);
}

float *get_outvec(art2 *n,int pattern)
{
  if(n->patterns->outvecs)
	  return (n->patterns->outvecs[pattern]);
  else 
	  return (NULL);
}

int valid_exemplars(art2 *n)
{
  return (F1->units == n->patterns->dimX);
}

float mag(float *x,int dim)
{
  int i;
  float sum = 0.0;
  for (i=0;i<dim;i++)
	  sum += (x[i] * x[i]);
  return (sqrt(sum));
}

void init_sublayers(art2 *n,float *inval)
{
  int i;
  float *l;
  for(i=0,l=n->f1.w; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.x; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.v; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.u; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.p; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.q; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=n->f1.r; i<F1->units; i++) *l++ = 0.0;
  for(i=0,l=I->outputs;i<I->units;i++) *l++ = inval[i];
  for(i=0,l=F1->outputs;i<F1->units;i++) *l++ = 0.0;
  for(i=0,l=F2->outputs;i<F2->units;i++) *l++ = 0.0;
}

float f(float x, float theta)
{
  if(x > theta) 
	  return x;
  else 
	  return 0.0;
}

void prop_through_sublayers(art2 *n)
{
  int i,dimI;
  float *w,*x,*u,*v,*p,*q,magW,magV,magP,theta;
  w = n->f1.w;
  x = n->f1.x;
  u = n->f1.u;
  v = n->f1.v;
  p = n->f1.p;
  q = n->f1.q;
  theta = n->theta;
  dimI = F1->units;
  for(i=0;i<dimI;i++)
	  w[i] = I->outputs[i] + n->A * u[i];
  magW = mag(w,dimI);
  for(i=0;i<dimI;i++)
	  x[i] = w[i] / (e + magW);

  for(i=0;i<dimI;i++)
	  v[i] = f(x[i],theta) + n->B * f(q[i],theta);
  magV = mag(v,dimI);
  for(i=0;i<dimI;i++)
	  u[i] = v[i]/(e + magV);

  for(i=0;i<dimI;i++)
	  p[i] = u[i] + F1->outputs[i];
  magP = mag(p,dimI);
  for(i=0;i<dimI;i++)
	  q[i] = p[i] / (e + magP);
}

void apply_input(art2 *n,float *invals)
{
  float *outvals,*p;
  int i,units;
  units = F1->units;
  outvals = F1->outputs;
  p = n->f1.p;
  init_sublayers(n,invals);
  prop_through_sublayers(n);
  prop_through_sublayers(n);
  for(i=0;i<units;i++)
	  outvals[i] = p[i];
}

void prop_through(art2 *n)
{
  int i;
  float *p,*u,*r,magU,magP;
  //propagate(F1,F2);
  //activate(F2);
 // propagate(F2,F1);
  p = n->f1.p;
  u = n->f1.u;
  r = n->f1.r;
  for(i=0;i<F1->units;i++)
	  p[i] = u[i] + F1->outputs[i];
  magU = mag(u,F1->units);
  magP = mag(p,F1->units);
  for(i=0;i<F1->units;i++)
	  r[i] = (u[i] + n->C *p[i]) / (e + magU + n->C * magP);
}

float compare_patterns(art2 *n)
{
  int i;
  float magR;
  magR = mag(n->f1.r,F1->units);
  return (n->rho / (e + magR));
}

void adjust_bottom_up_weights(art2 *n)
{
  int i,winner;
  float *wts,*u;
  winner = F2->processed;
  wts = F2->connects[winner];
  u = n->f1.u;
  for(i=0;i<F1->units;i++)
	  wts[i] = u[i] / (1.0 - n->D);
}

void adjust_top_down_weights(art2 *n)
{
  int i,j,winner;
  float *wts,**connects,*u;
  winner = F2->processed;
  connects = F1->connects;
  u = n->f1.u;
  for(i=0;i<F1->units;i++)
  {
    wts = connects[i];
	wts[winner] = u[i] / (1.0 - n->D);
  }
}

float *inhibit(int unit, layer *l,float *zeros)
{
  float *wts;
  wts = l->connects[unit];
  l->connects[unit] = zeros;
  return (wts);
}

void save_art2(art2 *n)
{
  char *outfile;
  FILE *fp;
  int i,j,dotpos;
  outfile = (char *)&n->filename;
  dotpos = position('.',outfile);
  if(dotpos >= 0) outfile[dotpos] = '\0';
  strcat(outfile,".ar2");
  if(!(fp = fopen(outfile,"w")))
  {
    printf("\nError: Could not open the file \" %s \" for data storage.",outfile);
	exit(0);
  }
  fwrite(&n->layers,sizeof(int),1,fp);
  for(i=0;i<n->layers;i++)
	  fwrite(&LAYER[i]->units,sizeof(int),1,fp);
  for(i=0;i<F1->units;i++)
	  fwrite(F1->connects[i],sizeof(float),F2->units,fp);
  fwrite(&F1->modifier,sizeof(float),1,fp);
  for(i=0;i<F2->units;i++)
	  fwrite(F2->connects[i],sizeof(float),F1->units,fp);
  fwrite(&F2->modifier,sizeof(float),1,fp);
  fclose(fp);
}

art2 *restore_art2(char *filename)
{
  art2 *n;
  int *ldata,layers,i;
  FILE *fp;
  if(!(fp = fopen(filename,"r")))
  {
    printf("\n Error: Could not open configuration file \" %s \"",filename);
	exit(0);
  }
  fread(&layers,sizeof(int),1,fp);
  ldata = (int *)calloc(layers+1,sizeof(int));
  for(i=1;i<=layers;i++)
	  fread(&ldata[i],sizeof(int),1,fp);
  ldata[0] = layers;
  n = build_art2(ldata);
  free(ldata);
  connect(F1,F2,COMPLETE,RANDOM);
  connect(F2,F1,COMPLETE,RANDOM);
  for(i=0;i<F1->units;i++)
	  fread(F1->connects[i],sizeof(float),F2->units,fp);
  fread(&F1->modifier,sizeof(float),1,fp);
  for(i=0;i<F2->units;i++)
	  fread(F2->connects[i],sizeof(float),F1->units,fp);
  fread(&F2->modifier,sizeof(float),1,fp);
  fclose(fp);
  return n;
}

int train_net(art2 *n,char *filename)
{
  int i,j,pattern,winner;
  float *p,degree_of_match,**savewts,*zeros;
  strcpy(n->filename,filename);
  n->exemplars = load_exemplars(filename,n->patterns);
  if(!valid_exemplars(n))
  {
	  printf("\n Error: Exemplars o not match network size!");
	  exit(0);
  }
  savewts = (float **)calloc(F2->units,sizeof(float *));
  zeros = (float *)calloc(F1->units,sizeof(float));
  for(i=0;i<F1->units;i++)  zeros[i] = 0.0;
  for(i=0;i<2;i++)
	  for(pattern=0;pattern<n->exemplars;pattern++)
	  {
	    for(j=0;j<F2->units;j++)
			savewts[j] = F2->connects[j];
		for(;;)
		{
		  apply_input(n,get_invec(n,pattern));
		  prop_through(n);
		  degree_of_match = compare_patterns(n);
		  if(degree_of_match <= 1.0)
			  break;
		  winner = F2->processed;
		  inhibit(winner,F2,zeros);
		}
		for(j=0;j<F2->units;j++)
			F2->connects[j] = savewts[j];
		adjust_bottom_up_weights(n);
		adjust_top_down_weights(n);
	  }
	  free(savewts);
	  free(zeros);
	  return (TRUE);
}

void set_parameters(layer *l,pfn p,afn a,float m)
{
  set_propagation(l,p);
  set_activation(l,a,m);
}

void set_art2_parameters(art2 *n, float a, float b,float c,float d,float theta,float rho)
{
  n->A = a;
  n->B = b;
  n->C = c;
  n->D = d;
  n->theta = theta;
  n->rho = rho;
}

void main()
{
  clrscr();
  art2 *n;
  int *layers;
  layers = define_layers(2,3,4);
  n = build_art2(layers);
  set_art2_parameters(n,10,10,0.1,0.9,0.2,0.9);
  F1->initval = 0.0;
  F2->initval = 1.0 / ((1.0 - n->D) * sqrt((float) F1->units)); 
  connect(F1,F2,COMPLETE,VALUE);
  connect(F2,F1,COMPLETE,VALUE);
  set_parameters(F1,DOT_PRODUCT,LINEAR,1.0);
  set_parameters(F2,DOT_PRODUCT,ON_CENTER,0.0);
  clrscr();
  if(train_net(n,"art2.dat"))
	  show_net(n);
  free(layers);
  destroy_art2(n);
}