art_int.c

自适应共振神经网络可以实现自动学习与分类具有自适应的功能

  for (i=0;i<art->max_nodes;i++)
    *(tempvflt+i)=*(art->elig+i);
  free(art->elig);
  art->elig = tempvflt;

  tempvint=(int *)malloc((size_t) ((art->max_nodes+new_nodes)*sizeof(int)));
  if (tempvint==NULL) return 1;
  for (i=0;i<art->max_nodes;i++)
    *(tempvint+i)=*(art->commit+i);
  free(art->commit);
  art->commit = tempvint;

  tempflt=(float **)malloc((size_t) (((art->max_nodes+new_nodes))*sizeof(float*)));
  if (tempflt==NULL) return 1;
  tempflt[0]=(float *)malloc((size_t) (((art->max_nodes+new_nodes)*art->num_inputs)*sizeof(float)));
  if (tempflt[0]==NULL) return 1;
  for(i=1;i<(art->max_nodes+new_nodes);i++)
    tempflt[i]=tempflt[i-1]+art->num_inputs;
  for (i=0;i<art->max_nodes;i++)
    for (j=0;j<art->num_inputs;j++)
      *(*(tempflt+i)+j)=*(*(art->weight+i)+j);
  free(art->weight[0]);   
  free(art->weight);
  art->weight = tempflt;


  tempvflt=(float *)malloc((size_t) ((art->max_nodes+new_nodes)*sizeof(float)));
  if (tempvflt==NULL) return 1;
  for (i=0;i<art->max_nodes;i++)
    *(tempvflt+i)=*(art->sum_weights+i);
  free(art->sum_weights);
  art->sum_weights = tempvflt;


  tempvflt=(float *)malloc((size_t) ((art->max_nodes+new_nodes)*sizeof(float)));
  if (tempvflt==NULL) return 1;
  for (i=0;i<art->max_nodes;i++)
    *(tempvflt+i)=*(art->sum_IW+i);
  free(art->sum_IW);
  art->sum_IW = tempvflt;
  
  /* Set Initial Weight Values for new weights                             */
  for (i=art->max_nodes;i<(art->max_nodes+new_nodes);i++)
    for (j=0;j<art->num_inputs;j++) 
      *(*(art->weight+i)+j)=1;

  /* Set Initial Commitments of new nodes to false                         */
  for (i=art->max_nodes;i<(art->max_nodes+new_nodes);i++)
    *(art->commit+i)=FALSE;

  /* Calculate initial weight sums for new nodes                           */
  for (i=art->max_nodes;i<(art->max_nodes+new_nodes);i++) {
    *(art->sum_weights+i)=0;
    for (j=0;j<art->num_inputs;j++)
      *(art->sum_weights+i)+=(*(*(art->weight+i)+j));
  }

  /* Update number of available nodes                                      */
  art->max_nodes=art->max_nodes+new_nodes;

  return 0;
}


/* -------------------------------------------------------------------------*/
/* AddMaps                                                                  */
/*           When using ARTMAP, this procedure needs to be called everytime */
/*           either the Art-A or Art-B networks change size (see AddCats).  */
/*           Allocates space for more mapfield nodes based on the new sizes */
/*           of the Art-A and Art-B networks and sets initial values for    */ 
/*           the newly allocated nodes and weights.                         */
/*                                                                          */
/* Return Value:                                                            */
/*           0 - If successful                                              */
/*           1 - When memory allocation failure                             */
/* -------------------------------------------------------------------------*/
int PREFIX  AddMaps(mapPTR map) {
  float *tempfltv;  /* Temporary pointer for copying                       */
  float **tempflt;  /* Temporary pointer for copying                       */
  int i,j;          /* Counters                                            */


  /* Allocate new space                                                    */
  tempflt=(float **)malloc((size_t) ((map->artA.max_nodes)*sizeof(float*)));
  if (tempflt==NULL) return 1;
  tempflt[0]=(float *)malloc((size_t) ((map->artA.max_nodes*map->artB.max_nodes)*sizeof(float)));
  if (tempflt[0]==NULL) return 1;
  for(i=1;i<map->artA.max_nodes;i++)
    tempflt[i]=tempflt[i-1]+map->artB.max_nodes;
  for (i=0;i<map->maxA_nodes;i++)
    for (j=0;j<map->maxB_nodes;j++)
      *(*(tempflt+i)+j)=*(*(map->map_weight+i)+j); 
  free(map->map_weight[0]);
  free(map->map_weight);
  map->map_weight=tempflt;


  tempfltv=(float *)malloc((size_t) (map->artB.max_nodes*sizeof(float)));
  if (tempfltv==NULL) return 1;
  for (i=0;i<map->maxB_nodes;i++)
    *(tempfltv+i)=*(map->map+i);
  free(map->map);
  map->map = tempfltv;


  /* Set initial weights of all new mapfield nodes                         */
  for (i=map->maxA_nodes;i<(map->artA.max_nodes);i++)
    for (j=0;j<map->artB.max_nodes;j++)           
      *(*(map->map_weight+i)+j)=1;
  for (i=0;i<map->artA.max_nodes;i++)
    for (j=map->maxB_nodes;j<(map->artB.max_nodes);j++) 
      *(*(map->map_weight+i)+j)=1;

  /* Update mapfield values                                                */
  map->maxA_nodes = map->artA.max_nodes;
  map->maxB_nodes = map->artB.max_nodes;

  return 0;
}


/* ------------------------------------------------------------------------- */
/* CheckPattern                                                              */
/*            Given a pattern set pointer and pattern data, check to make    */
/*            the pattern values fit the declared pattern type (BINARY or    */
/*            ANALOG) and if the are ANALOG that they are all between [0 1]. */
/*                                                                           */
/* Return errs:                                                              */
/*           0 - When successful                                             */
/*           1 - When input or output size is incompatible                   */
/*           2 - When ANALOG data given for BINARY set type                  */
/*           3 - When ALALOG pattern data is not properly bounded [0 1]      */
/*           4 - When input or output vector has only zero values            */
/* ------------------------------------------------------------------------- */
int PREFIX  CheckPattern (setPTR set, int num_inputs, float *input, int num_outputs, 
	    float *output) {
  int i;
  int zero_flag;

  /* Check size of input/output patterns                                  */
  if  (set->num_inputs!=num_inputs)   return 1;
  if  ((set->type_outputs!=NONE)&&(set->num_outputs!=num_outputs)) return 1;

  /* Check Input for ANALOG pattern in BINARY set                         */
  if (set->type_inputs==BINARY)
    for (i=0;i<num_inputs;i++)
      if (((*(input+i))!=1.0)&&((*(input+i))!=0.0)) return 2;
  
  /* Check Input for improperly bounded ANALOG patterns                   */
  if (set->type_inputs==ANALOG)
    for (i=0;i<num_inputs;i++)
      if (((*(input+i))>1.0)||((*(input+i))<0.0)) return 3;
 
  /* Check Output for ANALOG pattern in BINARY set                        */
  if (set->type_outputs==BINARY)
    for (i=0;i<num_outputs;i++)
      if (((*(output+i))!=1.0)&&((*(output+i))!=0.0)) return 2;
  
  /* Check Output for improperly bounded ANALOG patterns                  */
  if (set->type_outputs==ANALOG)
    for (i=0;i<num_outputs;i++)
      if (((*(output+i))>1.0)||((*(output+i))<0.0)) return 3;
  
  /* Check That At Least One Input is Non-Zero                            */
  zero_flag=TRUE;
  for (i=0;i<num_inputs;i++)
    if ((*(input+i))>0.0)
      zero_flag=FALSE;
  if (zero_flag)
    return 4;
  
  /* Check That At Least One Output is Non-Zero                           */
  if (set->type_outputs!=NONE) {
    zero_flag=TRUE;
    for (i=0;i<num_outputs;i++)
      if ((*(output+i))>0.0)
	zero_flag=FALSE;
    if (zero_flag)
      return 4;
  }

  /* Everything appears to be ok */
  return 0;
}


/* ------------------------------------------------------------------------- */
/* LoadArt                                                                   */
/*          Given a pointer to a file, loads art network data, setting       */
/*          appropriate initial values.                                      */
/*                                                                           */
/* Return Value:                                                             */
/*           0 - If successful                                               */
/*           1 - When memory allocation failure                              */
/*-------------------------------------------------------------------------- */
int PREFIX  LoadArt(artPTR art, FILE *LoadFile) {
  int   temp_int;
  float temp_flt;
  int   i,j;

  fscanf(LoadFile,"%i\n",&art->type);
  fscanf(LoadFile,"%i\n",&art->num_inputs);
  fscanf(LoadFile,"%i\n",&art->nodes_used);
  art->max_nodes        = art->nodes_used;  /* No unused nodes werre saved */

  art->cat=(float *)malloc((size_t) (art->max_nodes*sizeof(float)));
  if (art->cat==NULL) return 1;

  if (art->type!=NONE) {
    fscanf(LoadFile,"%i\n",&art->style);
    fscanf(LoadFile,"%f\n",&art->beta);
    fscanf(LoadFile,"%f\n",&art->vigil);
    art->num_reset        = 0;                /* Number Reset is zero        */
    
    
    /* Allocate space */
    art->elig=(float *)malloc((size_t) (art->max_nodes*sizeof(float)));
    if (art->elig==NULL) return 1;

    art->commit=(int *)malloc((size_t) (art->max_nodes*sizeof(int)));
    if (art->commit==NULL) return 1;

    art->weight=(float **)malloc((size_t) (art->max_nodes*sizeof(float*)));
    if (art->weight==NULL) return 1;
    art->weight[0]=(float *)malloc((size_t) ((art->max_nodes*art->num_inputs)*sizeof(float)));
    if (art->weight[0]==NULL) return 1;
    for(i=1;i<art->max_nodes;i++)
      art->weight[i]=art->weight[i-1]+art->num_inputs;

    art->sum_weights=(float *)malloc((size_t) (art->max_nodes*sizeof(float)));
    if (art->sum_weights==NULL) return 1;

    art->sum_IW=(float *)malloc((size_t) (art->max_nodes*sizeof(float)));
    if (art->sum_IW==NULL) return 1;


    /* Read in weights */
    for (i=0;i<art->nodes_used;i++) {
      for (j=0;j<art->num_inputs;j++) {
	fscanf(LoadFile,"%f ",&temp_flt);
	*(*(art->weight+i)+j)=temp_flt;
      }
      fscanf(LoadFile,"\n");
    }
    fscanf(LoadFile,"\n");
    
    /* Re-Calculate initial weight sums */
    for (i=0;i<art->max_nodes;i++) {
      *(art->sum_weights+i)=0;
      for (j=0;j<art->num_inputs;j++)
	*(art->sum_weights+i)+=(*(*(art->weight+i)+j));
    }
    
    /* Set Initial Commitments of used nodes to true */
    for (i=0;i<art->nodes_used;i++)
      *(art->commit+i)=TRUE;
  }
  return 0;
}


/* ------------------------------------------------------------------------- */
/* LoadMap                                                                   */
/*          Given a pointer to a file, loads mapfield data, setting          */
/*          appropriate initial values.                                      */
/*                                                                           */
/* Return Value:                                                             */
/*           0 - If successful                                               */
/*           1 - When memory allocation failure                              */
/*-------------------------------------------------------------------------- */
int PREFIX  LoadMap(mapPTR map, FILE *LoadFile) {
  int   temp_int;
  float temp_flt;
  int   i,j;

  fscanf(LoadFile,"%f\n",&map->vigil);
  fscanf(LoadFile,"%f\n",&map->base_vigil);

  map->num_mismatch = 0;                /* No mismatches yet */

  if (LoadArt(&map->artA,LoadFile)) return 1;
  if (LoadArt(&map->artB,LoadFile)) return 1;

  map->maxA_nodes       = map->artA.max_nodes;
  map->maxB_nodes       = map->artB.max_nodes;

  /* Allocate space */
  map->map=(float *)malloc((size_t) (map->artB.max_nodes*sizeof(float)));
  if (map->map==NULL) return 1;

  map->map_weight=(float **)malloc((size_t) (map->artA.max_nodes*sizeof(float*)));
  if (map->map_weight==NULL) return 1;
  map->map_weight[0]=(float *)malloc((size_t) ((map->artA.max_nodes*map->artB.max_nodes)*sizeof(float)));
  if (map->map_weight[0]==NULL) return 1;
  for(i=1;i<map->artA.max_nodes;i++)
    map->map_weight[i]=map->map_weight[i-1]+map->artB.max_nodes;


  /* Read in map weights */
  for (i=0;i<map->maxA_nodes;i++) {
    for (j=0;j<map->maxB_nodes;j++) {
      fscanf(LoadFile,"%f ",&temp_flt);
      *(*(map->map_weight+i)+j)=temp_flt;
    }
    fscanf(LoadFile,"\n");
  }
  fscanf(LoadFile,"\n");

  return 0;
}


/* ------------------------------------------------------------------------- */
/* SaveArt                                                                   */
/*          Given a pointer to a file, Saves art network data.               */
/*-------------------------------------------------------------------------- */
void PREFIX  SaveArt(artPTR art, FILE *SaveFile) {
  int   i,j;

  fprintf(SaveFile,"%i\n",art->type);
  fprintf(SaveFile,"%i\n",art->num_inputs);
  fprintf(SaveFile,"%i\n",art->nodes_used);

  if (art->type!=NONE) {
    fprintf(SaveFile,"%i\n",art->style);
    fprintf(SaveFile,"%f\n",art->beta);
    fprintf(SaveFile,"%f\n",art->vigil);
 
    /* Save weights */
    for (i=0;i<art->nodes_used;i++) {
      for (j=0;j<art->num_inputs;j++)
	fprintf(SaveFile,"%f ",(*(*(art->weight+i)+j)));
      fprintf(SaveFile,"\n");
    }
    fprintf(SaveFile,"\n");
  }
}


/* ------------------------------------------------------------------------- */
/* SaveMap                                                                   */
/*          Given a pointer to a file, Saves mapfield data.                  */
/*-------------------------------------------------------------------------- */
void PREFIX SaveMap(mapPTR map, FILE *SaveFile) {
  int   i,j;

  fprintf(SaveFile,"%f\n",map->vigil);
  fprintf(SaveFile,"%f\n",map->base_vigil);