somsd.c

SOM-sd 是现在国外非常流行的一个神经网络的结构自组织特征映射算法

      GetArg(TYPE_STRING, argc, argv, i++, &parameters->snap.file);
    else if (!strcmp(argv[i], "-snapinterval"))
      GetArg(TYPE_UNSIGNED, argc, argv, i++, &parameters->snap.interval);
    else if (!strcmp(argv[i], "-super"))
      parameters->super = GetSuperMode(argv[++i]);
    else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "-verbose"))
      parameters->verbose = 1;
    else if (!strcmp(argv[i], "-undirected")){
      parameters->undirected = 1;
      parameters->contextual = 1;
    }
    else if (!strcmp(argv[i], "-help") || !strcmp(argv[i], "-h") || !strcmp(argv[i], "-?")){
      Usage();
    }
    else{
      fprintf(stderr, "Warning: Ignoring unrecognized command line option '%s'\n", argv[i]);
    }

    if (CheckErrors() != 0)
      break;
  }

  return parameters;
}

/******************************************************************************
Description: Check given command line parameters for consistency, set default
          values if necessary, and print warnings if there unusual parameters
          are used.

Return value: The function does not return a value. 
******************************************************************************/
void CheckParameters(struct Parameters* parameters)
{
  char msg[256];

  fprintf(stderr, "Checking parameters");
  if (parameters->map.codes == NULL)
    AddError("No Map, or Map is empty.");

  if (parameters->datafile == NULL)
    AddError("No training data.");

  if (parameters->onetfile == NULL){
    parameters->onetfile = strdup("trained.net");  // Set default output file
    AddMessage("WARNING: Will save trained network to file 'trained.net'.");
    AddMessage("         Use option -cout to alter this behaviour.");
  }

  if (parameters->rlen == 0){
    AddMessage("WARNING: Number of training iterations not specified or zero.");
    AddMessage("         Training iterations defaults to: 64");
    AddMessage("         Use option -iter to alter this behaviour.");
    parameters->rlen  = 64;
  }

  if (parameters->alpha == 0.0)
    AddMessage("WARNING: Learning rate is zero.");

  if (parameters->alpha < 0.0)
    AddMessage("WARNING: Learning rate is negative!");

  if (parameters->alpha > 2.0){
    AddMessage("WARNING: Learning rate is likely to be too large.");
    AddMessage("         Suggested values for learning rate are within [0;1]");
  }

  if (parameters->alphatype == UNKNOWN)
    parameters->alphatype = ALPHA_SIGMOIDAL; /* Set default alpha type */

  if ((parameters->super == REJECT ||  parameters->super == LOCALREJECT)){
    if (parameters->beta == 0.0)
      AddMessage("WARNING: Rejection rate is zero in supervised mode.");
  }
  else if (parameters->beta != 0.0){
    parameters->beta = 0.0;
    AddMessage("Note: Not in corresponding supervised mode. Will ignore rejection rate.");
  }

  /* Check if a useful neigborhood radius is specified. In some cases a
     radius can be zero or negative. But in most cases it cannot. */
  if (parameters->radius == 0 && parameters->map.topology != TOPOL_VQ){
    AddMessage("WARNING: Neigborhood radius not specified or zero!");
    parameters->radius  = 1.0+sqrt(parameters->map.xdim * parameters->map.xdim + parameters->map.ydim * parameters->map.ydim)/9.0;
    sprintf(msg, "         Neigborhood radius defaults to: %d", parameters->radius);
    AddMessage(msg);
    AddMessage("         Use option -radius to alter this behaviour.");
  }

  /* Check seed values and initialize random number generator if needed */
  if (parameters->seed > 0)
    srand48(parameters->seed);

  if (parameters->batch == 0 && parameters->momentum != 0){
    parameters->batch = 1;   /* momentum term requires batch mode processing */
  }

  if (parameters->batch != 0){
    AddMessage("WARNING: Batch mode processing not yet implemented!");
    AddMessage("         Will proceed in default online mode.");
  }

  if (parameters->super != 0){
    AddMessage("WARNING: Supervised processing not yet implemented!");
    AddMessage("         Will proceed in default unsupervised mode.");
  }

  if (parameters->kernel != 0){
    AddMessage("WARNING: Kernel mode processing not yet implemented!");
    AddMessage("         Will proceed in default SOM-SD mode.");
  }

  if (parameters->ncpu == 0)
    parameters->ncpu = GetNumCPU();

  if (parameters->logfile == NULL || strlen(parameters->logfile) == 0)
    parameters->logfile = strdup("somsd.log");

  if (parameters->snap.interval > 0 && parameters->snap.file == NULL && parameters->snap.command == NULL){
    parameters->snap.file = strdup("snapshot.net");
    AddMessage("Note: Will save a snapshots to file 'snapshot.net'");
  }
  else if (parameters->snap.interval == 0 && parameters->snap.file != NULL){
    parameters->snap.interval = 1;
    AddMessage("Note: Will save a snapshots at every iteration");
  }

  SuggestMu(parameters);/* Compute optimal weight parameters */

  /* Print error and warning messages if there are any */
  if (CheckErrors()){
    fprintf(stderr, "%55s\n", "[FAILED]");
    return;
  }
  else{
    if (CheckMessages()){
      fprintf(stderr, "%55s\n", "[CAUTION]");
      PrintMessages();
      fprintf(stderr, "\n");
    }
    else
      fprintf(stderr, "%55s\n", "[OK]");
  }
}

/******************************************************************************
Description: main

Return value: zero
******************************************************************************/
int main(int argc, char **argv)
{
  struct Parameters parameters;
  time_t starttime;

  starttime = time(NULL);
  memset(&parameters, 0, sizeof(struct Parameters));
  parameters.alpha = 1.0; /* Default learning rate */
  GetParameters(&parameters, argc, argv);

  if (parameters.verbose){
    PrintSoftwareInfo(stderr); /* Print a nice header with software and */
    PrintSystemInfo(stderr);   /* hardware information */
  }

  if (CheckErrors() == 0)
    LoadMap(&parameters);  /* Load the map */

  if (CheckErrors() == 0)
    GetParameters(&parameters, argc, argv);  /* Overwrite network parameters*/

  if (CheckErrors() == 0)
    parameters.train = LoadData(parameters.datafile); /* Load training data */

  if (CheckErrors() == 0 && parameters.validfile != NULL)
    parameters.valid = LoadData(parameters.validfile);/*Load validation data*/

  if (CheckErrors() == 0)
    CheckParameters(&parameters);       /* Check for parameter consistancy  */

  if (CheckErrors() == 0 && parameters.undirected)      /* treat undirected */
    ConvertToUndirectedLinks(parameters.train);

  if (CheckErrors() == 0)
    PrepareData(&parameters);/* Prepare data for training phase */

  if (CheckErrors() == 0){
    TrainMap(&parameters); /* Train the network                 */ 
    SaveMap(&parameters);  /* Save the trained map              */
  }

  if (CheckErrors())       /* If there were errors then         */
    PrintErrors();         /* print them.                       */
  else{
    fprintf(stderr, "Total time: %s\n", PrintTime(time(NULL) - starttime));
    fprintf(stderr, "all done.\n");
  }

  /* Debugging stuff only */
  //  parameters.onetfile = strdup("test2");
  //SaveMapAscII(&parameters);    /* save the map to an asc-ii file.        */
  Cleanup(&parameters);         /* Free allocated memory and flush errors */

  return 0;
}

/* End of file */