fcm.cc

KNN algorithm, and related

  Real feature_value;
  FILE *learn_file;


  /* open the input training  file */
  learn_file = fopen(load_train_filename, "r");

  if ( learn_file == NULL) {
    fprintf(stderr, "Cannot open %s\n", load_train_filename);
    exit(EXIT_FAILURE);
  }

  /* scan for the number of features */
  fscanf( learn_file, "num_of_features = %d\n", &num_features);

  /* scan for the max number of classes M\n*/
  fscanf( learn_file, "num_of_classes = %d\n", &num_classes);

  if (debug) {
    fprintf( stdout, "num_of_features = %d\n", num_features);
    fprintf( stdout, "num_of_classes = %d\n", num_classes);
  }


  /* reserve area for the euclidianvector */
  ALLOC( euclidian_vector, num_classes );

  /* reserve area for the fuzzy_fcm_vector */
  ALLOC( fuzzy_fcm_vector, num_classes );

  /* reserve area for the mean feature matrix */
  ALLOC2D(mean_feature_matrix, num_classes, num_features);

  /* reserve area for the mean_feature_class_vector */
  ALLOC(mean_feature_class_vector, num_classes);

  /* reserve a character pointer ( char *) for each class name */
  ALLOC( class_name, num_classes ); 
  
  /* load feature matrix from learn file */
  if (verbose)
    fprintf(stdout, "Loading the training file...\n");

  
  for_less( k, 0, num_classes) {
    
    fscanf(learn_file, "class = %d\n", &mean_feature_class_vector[k]);    

    /* allocate some space for each class_name[k], 5 for ex and
       simulate itoa, this could be replaced by a more elegant looking
       code, when I have time */
    ALLOC( class_name[k], 5);
    sprintf( class_name[k], "%d", mean_feature_class_vector[k]); 

    for_less( j, 0, num_features) {
      fscanf(learn_file, "%lf\n", &feature_value);
      mean_feature_matrix[k][j] = feature_value ;
    }

  }

  if (debug > 2 ) {

    fprintf( stdout, "Printing mean_feature_matrix ...\n");
    for_less( i, 0, num_classes) {
      for_less( j, 0, num_features) 
	fprintf( stdout, "%f ", mean_feature_matrix[i][j]);
      fprintf( stdout, "%d\n", mean_feature_class_vector[i]);      
    }

    fprintf( stdout, "-----\n");
  }

  fclose(learn_file);

}


/* ----------------------------- MNI Header -----------------------------------
@NAME       : fcm_count_classes_and_set_names
@INPUT      : 
@OUTPUT     : 
@RETURNS    : 
@DESCRIPTION: sets num_classes, and class_names
@METHOD     : 
@GLOBALS    : 
@CALLS      : 
@CREATED    : Feb. 16 1996 (Vasco KOLLOKIAN)
@MODIFIED   : 
---------------------------------------------------------------------------- */
void fcm_count_classes_and_set_names(void)
{
 
  int i, tmp_idx = 0, max_idx = 0, src_idx = 0, dst_idx = 0;

  /* make sure class names are provided to be matched with training
     volumes. They are parsed and checked to have a least the same
     count as the number of training volumes supplied. Parsing is
     done similar to the above method */
  
  if ( !classname_buffer) {
    
    fprintf( stderr, "Please specify class names in quotes, with -class_names \n");
    exit(EXIT_FAILURE);
  }

  else {

    ALLOC2D(class_name, num_train_vols, 10 );

    if ( debug > 4 )
      fprintf( stdout, "classname buffer = %s\n", classname_buffer);
    
    for_less( i, 0, num_train_vols ) {

      /* while buf is not a ',' or null, advance pointer and copy character */
      while ( classname_buffer[src_idx] != ',' &&
	      classname_buffer[src_idx] != '\0' )
	class_name[i][dst_idx++] = classname_buffer[src_idx++];

      /* as soon as you encounter a ',' or null, end target string */
      class_name[i][dst_idx] = '\0';
	
      /* keep track of the highest class index */
      tmp_idx = atoi(class_name[i]);

      if ( tmp_idx > max_idx ) 
	max_idx = tmp_idx;

      if ( debug > 4 )
	fprintf( stdout, "class_name[%d] = %s\n", i, class_name[i]);

      /* reset target string pointer */     
      dst_idx = 0;

      /* if you reach the end of the string, and the number of class names 
	 is less than the number of training volumes die, else advance */      
      if (classname_buffer[src_idx] == '\0' && i != ( num_train_vols - 1 )) {

	fprintf( stderr, "The number of class names and training vol mismatch\n");
	exit(EXIT_FAILURE);
      }
      else
	src_idx++;
      
    } /* for_less */
    
  } /* else */

  num_classes = num_train_vols;

  max_class_index = max_idx;

  /* reserve some space */
  ALLOC( create_fuzzy_volume, num_classes );
  
  /* for each class, set fuzzy volume creation flag to true, since fcm  */
  for_less( i, 0, num_classes ) 
    create_fuzzy_volume[i] = 1;

}



/* ----------------------------- MNI Header -----------------------------------
@NAME       : fcm_classify_sample
@INPUT      : 
@OUTPUT     : 
@RETURNS    : sample class
@DESCRIPTION: given a feature vector and its size, return a class
@METHOD     : 
@GLOBALS    : 
@CALLS      : 
@CREATED    : Feb 16,, 1996 (Vasco KOLLOKIAN)
@MODIFIED   : 
---------------------------------------------------------------------------- */
void fcm_classify_sample(int *class_num, double *class_prob, int *class_labels)
{

  int           i, j;                  /* counters */
  Real          temp;                  /* temporary variable */
  Real          max_prob = 0.0;

  /* initialize delta vector */
  for_less ( i, 0, num_classes ) 
    euclidian_vector[i] = 0.0;
  
  /* calculate Euclidian distance */
  for_less ( i, 0,  num_classes )
    for_less ( j, 0, num_features) {

      temp = feature_vector[j] - mean_feature_matrix[i][j]; /* X - Z */
      euclidian_vector[i] += temp * temp;                   /* Sig ( X - Z ) ^2 */
    }


  /* calculate denominator of Sig[ ( || Xk -Vi || / || Xk - Vj || )^(2(m-1))]
     which is || Xk - Vj ||, here euclidian_vector[i] =  || Xk - Vj || 
     for all classes Vj */
  for_less( i, 0, num_classes) {

    temp = 0.0;

    for_less( j, 0, num_classes) 
      /* Sig[ ( || Xk -Vi || / || Xk - Vj || ) */
      temp += euclidian_vector[i] / euclidian_vector[j];

    /* uik = { Sig[ ( || Xk -Vi || / || Xk - Vj || )^(2(m-1))] }^-1, Bezdek*/
    /* here also sqrt of euc_vec is unnecessary by changing power to (1/(m-1)) */
    class_prob[i] = 1 / pow( temp, (1/(m-1)));

    /* keep track of max probability value to assign the label to class_num */
    if ( class_prob[i] > max_prob ) {

      max_prob = class_prob[i];
      *class_num = i;
    }
    
    class_labels[i] = atoi(class_name[i]) ;
 
  } /* for_less (i,0,num_classes ) */


} /* fcm_classify_sample */ 


/* ----------------------------- MNI Header -----------------------------------
@NAME       : fcm_save_training
@INPUT      : 
@OUTPUT     : 
@RETURNS    : 
@DESCRIPTION: 
@METHOD     : 
@GLOBALS    : 
@CALLS      : 
@CREATED    : Jun 3, 1995 (Vasco KOLLOKIAN)
@MODIFIED   : 
---------------------------------------------------------------------------- */
void fcm_save_training(char *save_train_filename)
{

  int i, j;                 /* counters */
  FILE *train_file;         /* save filename */


  train_file = fopen(save_train_filename, "w");


  /* see if the file could be opened */
  if ( train_file == NULL) {

    printf("Cannot open %s\n", save_train_filename);
    exit(EXIT_FAILURE);

  }

  /* store in the file the number of features trained on */
  fprintf(train_file, "num_of_features = %d\n", num_features);

  /* store in the file the max number of classes trained on */
  fprintf(train_file, "num_of_classes = %d\n", num_classes);
  
  for_less ( i, 0, num_classes ) {
    fprintf(train_file, "class = %d\n", mean_feature_class_vector[i]); 
    for_less ( j, 0, num_features )
      fprintf(train_file, "%lf ", mean_feature_matrix[i][j]); 
    fprintf(train_file, "\n");
  }

  fclose(train_file);

}