checkclusterer.java

来自「Java 编写的多种数据挖掘算法 包括聚类、分类、预处理等」· Java 代码 · 共 1,355 行 · 第 1/3 页

  protected boolean[] canTakeOptions() {
    
    boolean[] result = new boolean[2];
    
    print("options...");
    if (m_Clusterer instanceof OptionHandler) {
      println("yes");
      if (m_Debug) {
        println("\n=== Full report ===");
        Enumeration enu = ((OptionHandler)m_Clusterer).listOptions();
        while (enu.hasMoreElements()) {
          Option option = (Option) enu.nextElement();
          print(option.synopsis() + "\n" 
              + option.description() + "\n");
        }
        println("\n");
      }
      result[0] = true;
    }
    else {
      println("no");
      result[0] = false;
    }
    
    return result;
  }
  
  /**
   * Checks whether the scheme says it can handle instance weights.
   *
   * @return true if the clusterer handles instance weights
   */
  protected boolean[] weightedInstancesHandler() {
    
    boolean[] result = new boolean[2];
    
    print("weighted instances clusterer...");
    if (m_Clusterer instanceof WeightedInstancesHandler) {
      println("yes");
      result[0] = true;
    }
    else {
      println("no");
      result[0] = false;
    }
    
    return result;
  }
  
  /**
   * Checks whether the scheme handles multi-instance data.
   * 
   * @return true if the clusterer handles multi-instance data
   */
  protected boolean[] multiInstanceHandler() {
    boolean[] result = new boolean[2];
    
    print("multi-instance clusterer...");
    if (m_Clusterer instanceof MultiInstanceCapabilitiesHandler) {
      println("yes");
      result[0] = true;
    }
    else {
      println("no");
      result[0] = false;
    }
    
    return result;
  }
  
  /**
   * Checks basic prediction of the scheme, for simple non-troublesome
   * datasets.
   *
   * @param nominalPredictor if true use nominal predictor attributes
   * @param numericPredictor if true use numeric predictor attributes
   * @param stringPredictor if true use string predictor attributes
   * @param datePredictor if true use date predictor attributes
   * @param relationalPredictor if true use relational predictor attributes
   * @param multiInstance whether multi-instance is needed
   * @return index 0 is true if the test was passed, index 1 is true if test 
   *         was acceptable
   */
  protected boolean[] canPredict(
      boolean nominalPredictor,
      boolean numericPredictor, 
      boolean stringPredictor, 
      boolean datePredictor,
      boolean relationalPredictor,
      boolean multiInstance) {
    
    print("basic predict");
    printAttributeSummary(
        nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance);
    print("...");
    FastVector accepts = new FastVector();
    accepts.addElement("nominal");
    accepts.addElement("numeric");
    accepts.addElement("string");
    accepts.addElement("date");
    accepts.addElement("relational");
    accepts.addElement("multi-instance");
    accepts.addElement("not in classpath");
    int numTrain = getNumInstances(), numTest = getNumInstances(), 
    missingLevel = 0;
    boolean predictorMissing = false;
    
    return runBasicTest(nominalPredictor, numericPredictor, stringPredictor, 
        datePredictor, relationalPredictor, 
        multiInstance,
        missingLevel, predictorMissing, 
        numTrain, numTest, 
        accepts);
  }
  
  /**
   * Checks whether the scheme can handle zero training instances.
   *
   * @param nominalPredictor if true use nominal predictor attributes
   * @param numericPredictor if true use numeric predictor attributes
   * @param stringPredictor if true use string predictor attributes
   * @param datePredictor if true use date predictor attributes
   * @param relationalPredictor if true use relational predictor attributes
   * @param multiInstance whether multi-instance is needed
   * @return index 0 is true if the test was passed, index 1 is true if test 
   *         was acceptable
   */
  protected boolean[] canHandleZeroTraining(
      boolean nominalPredictor,
      boolean numericPredictor, 
      boolean stringPredictor, 
      boolean datePredictor,
      boolean relationalPredictor,
      boolean multiInstance) {
    
    print("handle zero training instances");
    printAttributeSummary(
        nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance);
    print("...");
    FastVector accepts = new FastVector();
    accepts.addElement("train");
    accepts.addElement("value");
    int numTrain = 0, numTest = getNumInstances(), 
    missingLevel = 0;
    boolean predictorMissing = false;
    
    return runBasicTest(
              nominalPredictor, numericPredictor, stringPredictor, 
              datePredictor, relationalPredictor, 
              multiInstance,
              missingLevel, predictorMissing,
              numTrain, numTest, 
              accepts);
  }
  
  /**
   * Checks whether the scheme correctly initialises models when 
   * buildClusterer is called. This test calls buildClusterer with
   * one training dataset and records performance on a test set. 
   * buildClusterer is then called on a training set with different
   * structure, and then again with the original training set. The
   * performance on the test set is compared with the original results
   * and any performance difference noted as incorrect build initialisation.
   *
   * @param nominalPredictor if true use nominal predictor attributes
   * @param numericPredictor if true use numeric predictor attributes
   * @param stringPredictor if true use string predictor attributes
   * @param datePredictor if true use date predictor attributes
   * @param relationalPredictor if true use relational predictor attributes
   * @param multiInstance whether multi-instance is needed
   * @return index 0 is true if the test was passed
   */
  protected boolean[] correctBuildInitialisation(
      boolean nominalPredictor,
      boolean numericPredictor, 
      boolean stringPredictor, 
      boolean datePredictor,
      boolean relationalPredictor,
      boolean multiInstance) {

    boolean[] result = new boolean[2];
    
    print("correct initialisation during buildClusterer");
    printAttributeSummary(
        nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance);
    print("...");
    int numTrain = getNumInstances(), numTest = getNumInstances(), missingLevel = 0;
    boolean predictorMissing = false;
    
    Instances train1 = null;
    Instances test1 = null;
    Instances train2 = null;
    Instances test2 = null;
    Clusterer clusterer = null;
    ClusterEvaluation evaluation1A = null;
    ClusterEvaluation evaluation1B = null;
    ClusterEvaluation evaluation2 = null;
    boolean built = false;
    int stage = 0;
    try {
      
      // Make two sets of train/test splits with different 
      // numbers of attributes
      train1 = makeTestDataset(42, numTrain, 
                               nominalPredictor ? 2 : 0,
                               numericPredictor ? 1 : 0, 
                               stringPredictor ? 1 : 0, 
                               datePredictor ? 1 : 0, 
                               relationalPredictor ? 1 : 0, 
                               multiInstance);
      train2 = makeTestDataset(84, numTrain, 
                               nominalPredictor ? 3 : 0,
                               numericPredictor ? 2 : 0, 
                               stringPredictor ? 1 : 0, 
                               datePredictor ? 1 : 0, 
                               relationalPredictor ? 1 : 0, 
                               multiInstance);
      test1 = makeTestDataset(24, numTest,
                              nominalPredictor ? 2 : 0,
                              numericPredictor ? 1 : 0, 
                              stringPredictor ? 1 : 0, 
                              datePredictor ? 1 : 0, 
                              relationalPredictor ? 1 : 0, 
                              multiInstance);
      test2 = makeTestDataset(48, numTest,
                              nominalPredictor ? 3 : 0,
                              numericPredictor ? 2 : 0, 
                              stringPredictor ? 1 : 0, 
                              datePredictor ? 1 : 0, 
                              relationalPredictor ? 1 : 0, 
                              multiInstance);
      if (nominalPredictor && !multiInstance) {
        train1.deleteAttributeAt(0);
        test1.deleteAttributeAt(0);
        train2.deleteAttributeAt(0);
        test2.deleteAttributeAt(0);
      }
      if (missingLevel > 0) {
        addMissing(train1, missingLevel, predictorMissing);
        addMissing(test1, Math.min(missingLevel,50), predictorMissing);
        addMissing(train2, missingLevel, predictorMissing);
        addMissing(test2, Math.min(missingLevel,50), predictorMissing);
      }
      
      clusterer = Clusterer.makeCopies(getClusterer(), 1)[0];
      evaluation1A = new ClusterEvaluation();
      evaluation1B = new ClusterEvaluation();
      evaluation2 = new ClusterEvaluation();
    } catch (Exception ex) {
      throw new Error("Error setting up for tests: " + ex.getMessage());
    }
    try {
      stage = 0;
      clusterer.buildClusterer(train1);
      evaluation1A.setClusterer(clusterer);
      evaluation1A.evaluateClusterer(train1);
      built = true;
      
      stage = 1;
      built = false;
      clusterer.buildClusterer(train2);
      evaluation2.setClusterer(clusterer);
      evaluation2.evaluateClusterer(train2);
      built = true;
      
      stage = 2;
      built = false;
      clusterer.buildClusterer(train1);
      evaluation1B.setClusterer(clusterer);
      evaluation1B.evaluateClusterer(train1);
      built = true;
      
      stage = 3;
      if (!evaluation1A.equals(evaluation1B)) {
        if (m_Debug) {
          println("\n=== Full report ===\n");
          println("First buildClusterer()");
          println(evaluation1A.clusterResultsToString() + "\n\n");
          println("Second buildClusterer()");
          println(evaluation1B.clusterResultsToString() + "\n\n");
        }
        throw new Exception("Results differ between buildClusterer calls");
      }
      println("yes");
      result[0] = true;
      
      if (false && m_Debug) {
        println("\n=== Full report ===\n");
        println("First buildClusterer()");
        println(evaluation1A.clusterResultsToString() + "\n\n");
        println("Second buildClusterer()");
        println(evaluation1B.clusterResultsToString() + "\n\n");
      }
    } 
    catch (Exception ex) {
      println("no");
      result[0] = false;
      if (m_Debug) {
        println("\n=== Full Report ===");
        print("Problem during");
        if (built) {
          print(" testing");
        } else {
          print(" training");
        }
        switch (stage) {
          case 0:
            print(" of dataset 1");
            break;
          case 1:
            print(" of dataset 2");
            break;
          case 2:
            print(" of dataset 1 (2nd build)");
            break;
          case 3:
            print(", comparing results from builds of dataset 1");
            break;	  
        }
        println(": " + ex.getMessage() + "\n");
        println("here are the datasets:\n");
        println("=== Train1 Dataset ===\n"
            + train1.toString() + "\n");
        println("=== Test1 Dataset ===\n"
            + test1.toString() + "\n\n");
        println("=== Train2 Dataset ===\n"
            + train2.toString() + "\n");
        println("=== Test2 Dataset ===\n"
            + test2.toString() + "\n\n");
      }
    }
    
    return result;
  }
  
  /**
   * Checks basic missing value handling of the scheme. If the missing
   * values cause an exception to be thrown by the scheme, this will be
   * recorded.
   *
   * @param nominalPredictor if true use nominal predictor attributes
   * @param numericPredictor if true use numeric predictor attributes
   * @param stringPredictor if true use string predictor attributes
   * @param datePredictor if true use date predictor attributes
   * @param relationalPredictor if true use relational predictor attributes
   * @param multiInstance whether multi-instance is needed
   * @param predictorMissing true if the missing values may be in 
   * the predictors
   * @param missingLevel the percentage of missing values
   * @return index 0 is true if the test was passed, index 1 is true if test 
   *         was acceptable
   */
  protected boolean[] canHandleMissing(
      boolean nominalPredictor,
      boolean numericPredictor, 
      boolean stringPredictor, 
      boolean datePredictor,
      boolean relationalPredictor,
      boolean multiInstance,
      boolean predictorMissing,
      int missingLevel) {
    
    if (missingLevel == 100)
      print("100% ");
    print("missing");
    if (predictorMissing) {
      print(" predictor");
    }
    print(" values");
    printAttributeSummary(
        nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance);
    print("...");
    FastVector accepts = new FastVector();
    accepts.addElement("missing");
    accepts.addElement("value");
    accepts.addElement("train");
    int numTrain = getNumInstances(), numTest = getNumInstances();
    
    return runBasicTest(nominalPredictor, numericPredictor, stringPredictor, 
        datePredictor, relationalPredictor, 
        multiInstance,
        missingLevel, predictorMissing,
        numTrain, numTest, 
        accepts);
  }
  
  /**
   * Checks whether the clusterer can handle instance weights.
   * This test compares the clusterer performance on two datasets
   * that are identical except for the training weights. If the 
   * results change, then the clusterer must be using the weights. It
   * may be possible to get a false positive from this test if the 
   * weight changes aren't significant enough to induce a change
   * in clusterer performance (but the weights are chosen to minimize
   * the likelihood of this).
   *
   * @param nominalPredictor if true use nominal predictor attributes
   * @param numericPredictor if true use numeric predictor attributes
   * @param stringPredictor if true use string predictor attributes
   * @param datePredictor if true use date predictor attributes
   * @param relationalPredictor if true use relational predictor attributes
   * @param multiInstance whether multi-instance is needed
   * @return index 0 true if the test was passed
   */
  protected boolean[] instanceWeights(
      boolean nominalPredictor,
      boolean numericPredictor, 
      boolean stringPredictor, 
      boolean datePredictor,
      boolean relationalPredictor,
      boolean multiInstance) {
    
    print("clusterer uses instance weights");
    printAttributeSummary(
        nominalPredictor, numericPredictor, stringPredictor, datePredictor, relationalPredictor, multiInstance);
    print("...");
    int numTrain = 2*getNumInstances(), numTest = getNumInstances(), missingLevel = 0;
    boolean predictorMissing = false;
    
    boolean[] result = new boolean[2];
    Instances train = null;
    Instances test = null;
    Clusterer [] clusterers = null;
    ClusterEvaluation evaluationB = null;
    ClusterEvaluation evaluationI = null;
    boolean built = false;
    boolean evalFail = false;
    try {
      train = makeTestDataset(42, numTrain, 
                              nominalPredictor ? 3 : 0,
                              numericPredictor ? 2 : 0, 
                              stringPredictor ? 1 : 0, 
                              datePredictor ? 1 : 0, 
                              relationalPredictor ? 1 : 0, 
                              multiInstance);
      test = makeTestDataset(24, numTest,
                             nominalPredictor ? 3 : 0,
                             numericPredictor ? 2 : 0, 
                             stringPredictor ? 1 : 0, 
                             datePredictor ? 1 : 0, 
                             relationalPredictor ? 1 : 0, 
                             multiInstance);
      if (nominalPredictor && !multiInstance) {
        train.deleteAttributeAt(0);
        test.deleteAttributeAt(0);
      }
      if (missingLevel > 0) {
        addMissing(train, missingLevel, predictorMissing);
        addMissing(test, Math.min(missingLevel, 50), predictorMissing);
      }
      clusterers = Clusterer.makeCopies(getClusterer(), 2);
      evaluationB = new ClusterEvaluation();