cli.c

聚类算法全集以及内附数据集

{                               /* --- get code of processing mode */
  for ( ; tab->name; tab++)     /* look up name in table */
    if (strcmp(tab->name, name) == 0)
      return tab->code;         /* return the code of the init. mode */
  return -1;                    /* or an error indicator */
}  /* code() */

/*--------------------------------------------------------------------*/

int main (int argc, char *argv[])
{                               /* --- main function */
  int    i, k = 0, n;           /* loop variables, buffers */
  char   *s;                    /* to traverse options */
  char   **optarg = NULL;       /* option argument */
  #ifdef MATVERSION
  char   *fn_in   = NULL;       /* name of input cluster file */
  #else
  char   *fn_dom  = NULL;       /* name of domain file */
  char   *fn_hdr  = NULL;       /* name of table header file */
  char   *trgname = NULL;       /* name of optional target attribute */
  #endif
  char   *fn_pat  = NULL;       /* name of table/pattern file */
  char   *fn_out  = NULL;       /* name of output cluster file */
  char   *blanks  = NULL;       /* blank  characters */
  char   *fldseps = NULL;       /* field  separators */
  char   *recseps = NULL;       /* record separators */
  char   *ininame = "points";   /* name of initialization mode */
  char   *nrmname = "sum1";     /* name of normalization mode */
  char   *updname = "altopt";   /* name of parameter update method */
  char   *modname = "none";     /* name of parameter update modifier */
  int    clscnt   = 2;          /* number of clusters */
  int    type     = CLS_CENTER; /* cluster type */
  double rfnps[]  = {2, 0};     /* radial function parameters */
  int    gauss    = 0;          /* flag for Gaussian function */
  int    nrmmode  = 0;          /* normalization mode */
  double nrmps[]  = {1, 0};     /* normalization parameters */
  double noise    = 0;          /* m.s. degree to noise cluster */
  int    owrite   = 0;          /* overwrite parameters with options */
  int    irnorm   = 1;          /* flag for input range normalization */
  int    inimode  = 0;          /* initialization mode */
  int    seed     = (int)time(NULL); /* seed value for random numbers */
  double range    = 0;          /* range for random offsets */
  double radius   = 1.0;        /* initial cluster size (radius) */
  int    method   = 0;          /* parameter update method */
  int    epochs   = 1000;       /* number of update epochs */
  int    update   = 0;          /* number of patterns between updates */
  int    conly    = 0;          /* epochs to update centers only */
  int    shuffle  = 1;          /* shuffle pattern set */
  double trmchg   = 0;          /* maximum change for termination */
  double msexp    = 2.0;        /* membership exponent for adaptation */
  double regps[]  = {0,1,1,0,0};/* regularization parameters */
  double lrates[] = {0.2,0.2,0.2}; /* learning rates */
  double decays[] = {-.2,-.2,-.2}; /* learning rate decay params. */
  double moment   = 0;          /* momentum term coefficient */
  double growth   = 1.2;        /* growth factor for learning rate */
  double shrink   = 0.5;        /* shrink factor for learning rate */
  double minchg   = 0;          /* minimal change (resilient update) */
  double maxchg   = 2;          /* maximal change (resilient update) */
  int    maxlen   = 0;          /* maximal output line length */
  int    dmode    = CLS_TITLE;  /* description mode */
  double chg, t;                /* maximal change of a center coord. */
  #ifdef MATVERSION
  int    exclude  = 0;          /* number of target fields to exclude */
  int    attcnt   = 0;          /* number of attributes */
  int    patcnt   = 0;          /* number of patterns */
  MATRIX *submat;               /* submatrix for usable columns */
  TFSERR *err;                  /* error information */
  #else
  int    flags    = AS_NOXATT|AS_NOUNKS;  /* table file read flags */
  TUPLE  *tpl;                  /* to traverse the patterns */
  #endif

  prgname = argv[0];            /* get program name for error msgs. */

  /* --- print startup/usage message --- */
  if (argc > 1) {               /* if arguments are given */
    fprintf(stderr, "%s - %s\n", argv[0], DESCRIPTION);
    fprintf(stderr, VERSION); } /* print a startup message */
  else {                        /* if no argument given */
    #ifdef MATVERSION
    printf("usage: %s [options] patfile outfile [infile]\n", argv[0]);
    #else
    printf("usage: %s [options] domfile "
                    "[-d|-h hdrfile] tabfile outfile\n", argv[0]);
    #endif
    printf("%s\n", DESCRIPTION);
    printf("%s\n", VERSION);
    printf("-!       print a list of init. and norm. modes "
                    "and update methods\n");
    printf("-c#      number of clusters               "
                    "(default: %d)\n", clscnt);
    printf("-Z       adaptable size                   "
                    "(default: fixed size)\n");
    printf("-v       adaptable variances              "
                    "(default: unit variances)\n");
    printf("-V       adaptable covariances            "
                    "(default: unit matrix)\n");
    printf("-w       adaptable weights/prior probs.   "
                    "(default: equal weights)\n");
    printf("-N       normalize to unit integral       "
                    "(default: no normalization)\n");
    printf("-G       Gaussian radial function         "
                    "(default: Cauchy function)\n");
    printf("-p#:#    radial function parameters       "
                    "(default: %g:%g)\n", rfnps[0], rfnps[1]);
    printf("-y#      membership to noise cluster      "
                    "(default: %g)\n", noise);
    printf("-J#:#    membership transform parameters  "
                    "(default: %g:%g)\n", nrmps[0], nrmps[1]);
    printf("-j#      membership normalization mode    "
                    "(default: %s)\n", nrmname);
    printf("-O       overwrite with option values     "
                    "(default: parameters read)\n");
    #ifdef MATVERSION
    printf("-X#      number of fields to exclude      "
                    "(default: use all fields)\n");
    #else
    printf("-X#      exclude a target attribute       "
                    "(default: use all attributes)\n");
    #endif
    printf("-q       do not normalize input ranges    "
                    "(default: mean=0, var=1)\n");
    printf("-S#      seed for random numbers          "
                    "(default: time)\n");
    printf("-i#      initialization mode              "
                    "(default: %s)\n", ininame);
    printf("-o#      random offset range              "
                    "(default: %g)\n", range);
    printf("-I#      initial cluster size (radius)    "
                    "(default: %g)\n", radius);
    printf("-a#      parameter update method          "
                    "(default: %s)\n", updname);
    printf("-A#      parameter update modifier        "
                    "(default: %s)\n", modname);
    printf("-0       fix centers at origin            "
                    "(default: free centers)\n");
    printf("-U       normalize centers to unit length "
                    "(default: no normalization)\n");
    printf("-s       do not shuffle patterns          "
                    "(default: once per epoch)\n");
    printf("-e#      maximum number of update epochs  "
                    "(default: %d)\n", epochs);
    printf("-k#      patterns between two updates     "
                    "(default: %d)\n", update);
    printf("-C#      epochs to update centers only    "
                    "(default: %d)\n", conly);
    printf("-T#      maximum change for termination   "
                    "(default: %g)\n", trmchg);
    printf("-x#      exponent for pattern weight      "
                    "(default: %g)\n", msexp);
    printf("-H#      shape regularization parameter   "
                    "(default: %g)\n", regps[3]);
    printf("-R#:#:#  size  regularization parameters  "
                    "(default: %g:%g:%g)\n",
                     regps[0], regps[1], regps[2]);
    printf("-W#      weight regularization parameter  "
                    "(default: %g)\n", regps[4]);
    printf("-t#:#:#  learning rates                   "
                    "(default: %g:%g:%g)\n",
                     lrates[0], lrates[1], lrates[2]);
    printf("-D#:#:#  learning rates decay parameters  "
                    "(default: %g:%g:%g)\n",
                     decays[0], decays[1], decays[2]);
    printf("-m#      momentum coefficient             "
                    "(default: %g)\n", moment);
    printf("-g#:#    growth and shrink factor         "
                    "(default: %g:%g)\n", growth, shrink);
    printf("-z#:#    range of change/learning rate    "
                    "(default: %g:%g)\n", minchg, maxchg);
    printf("-l#      output line length               "
                    "(default: no limit)\n");
    printf("-b/f/r#  blank characters, field and record separators\n"
           "         (default: \" \\t\\r\", \" \\t\", \"\\n\")\n");
    #ifdef MATVERSION
    printf("patfile  pattern file to read (no header, only numbers)\n");
    printf("outfile  file to write induced cluster set to\n");
    printf("infile   file to read initial cluster set from "
                    "(optional)\n");
    #else
    printf("-n       number of tuple occurrences in last field\n");
    printf("domfile  file containing domain descriptions\n"
           "         (and optionally an initial cluster set)\n");
    printf("-d       use default header "
                    "(field names = field numbers)\n");
    printf("-h       read table header (field names) from hdrfile\n");
    printf("hdrfile  file containing table header (field names)\n");
    printf("tabfile  table file to read "
                    "(field names in first record)\n");
    printf("outfile  file to write induced cluster set to\n");
    #endif
    return 0;                   /* print a usage message */
  }                             /* and abort the program */

  /* --- evaluate arguments --- */
  for (i = 1; i < argc; i++) {  /* traverse arguments */
    s = argv[i];                /* get option argument */
    if (optarg) { *optarg = s; optarg = NULL; continue; }
    if ((*s == '-') && *++s) {  /* -- if argument is an option */
      while (1) {               /* traverse characters */
        switch (*s++) {         /* evaluate option */
          case '!': help();                              break;
          case 'c': clscnt  = (int)strtol(s, &s, 0);     break;
          case 'Z': type   |= CLS_SIZE;                  break;
          case 'v': type   |= CLS_VARS;                  break;
          case 'V': type   |= CLS_COVARS;                break;
          case 'w': type   |= CLS_WEIGHT;                break;
          case 'N': type   |= CLS_NORM;                  break;
          case 'G': gauss   = 1;                         break;
          case 'p': getdblvec(s, &s, 2, rfnps);          break;
          case 'y': noise   =      strtod(s, &s);        break;
          case 'J': getdblvec(s, &s, 2, nrmps);          break;
          case 'j': optarg  = &nrmname;                  break;
          case 'O': owrite  = 1;                         break;
          #ifdef MATVERSION
          case 'X': exclude = (int)strtol(s, &s, 0);     break;
          #else
          case 'X': optarg  = &trgname;                  break;
          #endif
          case 'q': irnorm  = 0;                         break;
          case 'S': seed    = (int)strtol(s, &s, 0);     break;
          case 'i': optarg  = &ininame;                  break;
          case 'o': range   =      strtod(s, &s);        break;
          case 'I': radius  =      strtod(s, &s);        break;
          case 'a': optarg  = &updname;                  break;
          case 'A': optarg  = &modname;                  break;
          case '0': method |= CLS_ORIGIN;                break;
          case 'U': method |= CLS_UNIT;                  break;
          case 's': shuffle = 0;                         break;
          case 'e': epochs  = (int)strtol(s, &s, 0);     break;
          case 'k': update  = (int)strtol(s, &s, 0);     break;
          case 'C': conly   = (int)strtol(s, &s, 0);     break;
          case 'T': trmchg  =      strtod(s, &s);        break;
          case 'x': msexp   =      strtod(s, &s);        break;
          case 'H': getdbls(s, &s, 1, regps+3);          break;
          case 'R': getdblvec(s, &s, 3, regps);          break;
          case 'W': getdbls(s, &s, 1, regps+4);          break;
          case 't': getdblvec(s, &s, 3, lrates);         break;
          case 'D': getdblvec(s, &s, 3, decays);         break;
          case 'm': moment  =      strtod(s, &s);        break;
          case 'g': getdbls(s, &s, 2, &growth, &shrink); break;
          case 'z': getdbls(s, &s, 2, &minchg, &maxchg); break;
          case 'l': maxlen  = (int)strtol(s, &s, 0);     break;
          case 'b': optarg  = &blanks;                   break;
          case 'f': optarg  = &fldseps;                  break;
          case 'r': optarg  = &recseps;                  break;
          #ifndef MATVERSION
          case 'n': flags  |= AS_WEIGHT;                 break;
          case 'd': flags  |= AS_DFLT;                   break;
          case 'h': optarg  = &fn_hdr;                   break;
          #endif
          default : error(E_OPTION, *--s);               break;
        }                       /* set option variables */
        if (!*s) break;         /* if at end of string, abort loop */
        if (optarg) { *optarg = s; optarg = NULL; break; }
      } }                       /* get option argument */
    else {                      /* -- if argument is no option */
      switch (k++) {            /* evaluate non-option */
        #ifdef MATVERSION
        case  0: fn_pat = s;      break;
        case  1: fn_out = s;      break;
        case  2: fn_in  = s;      break;
        #else
        case  0: fn_dom = s;      break;
        case  1: fn_pat = s;      break;
        case  2: fn_out = s;      break;
        #endif
        default: error(E_ARGCNT); break;
      }                         /* note filenames */
    }
  }
  if (optarg) error(E_OPTARG);  /* check the option argument */