Java 类weka.core.UnsupportedClassTypeException 实例源码

/**
 * Builds Id3 decision tree classifier.
 * 
 * @param data
 *            the training data
 * @exception Exception
 *                if classifier can't be built successfully
 */
public void buildClassifier(Instances data) throws Exception {
    if (!data.classAttribute().isNominal()) {
        throw new UnsupportedClassTypeException("Id3: nominal class, please.");
    }
    Enumeration enumAtt = data.enumerateAttributes();
    while (enumAtt.hasMoreElements()) {
        if (!((Attribute) enumAtt.nextElement()).isNominal()) {
            throw new UnsupportedAttributeTypeException("Id3: only nominal "
                + "attributes, please.");
        }
    }
    data = new Instances(data);
    data.deleteWithMissingClass();
    makeTree(data);
}

/**
 * Calculates the class membership probabilities for the given test instance.
 *
 * @param instance the instance to be classified
 * @return predicted class probability distribution
 * @throws Exception if distribution can't be computed successfully
 */
public double[] distributionForInstance(Instance instance) throws Exception {
    if (instance.classAttribute().isNumeric()) {
 throw new UnsupportedClassTypeException("Decorate can't handle a numeric class!");
    }
    double [] sums = new double [instance.numClasses()], newProbs; 
    Classifier curr;

    for (int i = 0; i < m_Committee.size(); i++) {
 curr = (Classifier) m_Committee.get(i);
 newProbs = curr.distributionForInstance(instance);
 for (int j = 0; j < newProbs.length; j++)
   sums[j] += newProbs[j];
    }
    if (Utils.eq(Utils.sum(sums), 0)) {
 return sums;
    } else {
 Utils.normalize(sums);
 return sums;
    }
}

/**
    * Builds a single rule learner with REP dealing with 2 classes.
    * This rule learner always tries to predict the class with label 
    * m_Class.
    *
    * @param instances the training data
    * @throws Exception if classifier can't be built successfully
    */
   public void buildClassifier(Instances instances) throws Exception {
     m_ClassAttribute = instances.classAttribute();
     if (!m_ClassAttribute.isNominal()) 
throw new UnsupportedClassTypeException(" Only nominal class, please.");
     if(instances.numClasses() != 2)
throw new Exception(" Only 2 classes, please.");

     Instances data = new Instances(instances);
     if(Utils.eq(data.sumOfWeights(),0))
throw new Exception(" No training data.");

     data.deleteWithMissingClass();
     if(Utils.eq(data.sumOfWeights(),0))
throw new Exception(" The class labels of all the training data are missing."); 

     if(data.numInstances() < m_Folds)
throw new Exception(" Not enough data for REP.");

     m_Antds = new FastVector();    

     /* Split data into Grow and Prune*/
     m_Random = new Random(m_Seed);
     data.randomize(m_Random);
     data.stratify(m_Folds);
     Instances growData=data.trainCV(m_Folds, m_Folds-1, m_Random);
     Instances pruneData=data.testCV(m_Folds, m_Folds-1);

     grow(growData);      // Build this rule

     prune(pruneData);    // Prune this rule
   }