gyc.OverBoostM1.java Source code

Java tutorial

Introduction

Here is the source code for gyc.OverBoostM1.java

Source

/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 *    AdaBoostM1.java
 *    Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
 *
 */

package gyc;

import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.RandomizableIteratedSingleClassifierEnhancer;
import weka.classifiers.Sourcable;
import weka.core.Capabilities;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Option;
import weka.core.Randomizable;
import weka.core.RevisionUtils;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformationHandler;
import weka.core.Utils;
import weka.core.WeightedInstancesHandler;
import weka.core.Capabilities.Capability;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;

import java.util.Enumeration;
import java.util.Random;
import java.util.Vector;

/**
 <!-- globalinfo-start -->
 * Class for boosting a nominal class classifier using the Adaboost M1 method. Only nominal class problems can be tackled. Often dramatically improves performance, but sometimes overfits.<br/>
 * <br/>
 * For more information, see<br/>
 * <br/>
 * Yoav Freund, Robert E. Schapire: Experiments with a new boosting algorithm. In: Thirteenth International Conference on Machine Learning, San Francisco, 148-156, 1996.
 * <p/>
 <!-- globalinfo-end -->
 *
 <!-- technical-bibtex-start -->
 * BibTeX:
 * <pre>
 * &#64;inproceedings{Freund1996,
 *    address = {San Francisco},
 *    author = {Yoav Freund and Robert E. Schapire},
 *    booktitle = {Thirteenth International Conference on Machine Learning},
 *    pages = {148-156},
 *    publisher = {Morgan Kaufmann},
 *    title = {Experiments with a new boosting algorithm},
 *    year = {1996}
 * }
 * </pre>
 * <p/>
 <!-- technical-bibtex-end -->
 *
 <!-- options-start -->
 * Valid options are: <p/>
 * 
 * <pre> -P &lt;num&gt;
 *  Percentage of weight mass to base training on.
 *  (default 100, reduce to around 90 speed up)</pre>
 * 
 * <pre> -Q
 *  Use resampling for boosting.</pre>
 * 
 * <pre> -S &lt;num&gt;
 *  Random number seed.
 *  (default 1)</pre>
 * 
 * <pre> -I &lt;num&gt;
 *  Number of iterations.
 *  (default 10)</pre>
 * 
 * <pre> -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console</pre>
 * 
 * <pre> -W
 *  Full name of base classifier.
 *  (default: weka.classifiers.trees.DecisionStump)</pre>
 * 
 * <pre> 
 * Options specific to classifier weka.classifiers.trees.DecisionStump:
 * </pre>
 * 
 * <pre> -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console</pre>
 * 
 <!-- options-end -->
 *
 * Options after -- are passed to the designated classifier.<p>
 *
 * @author Eibe Frank (eibe@cs.waikato.ac.nz)
 * @author Len Trigg (trigg@cs.waikato.ac.nz)
 * @version $Revision: 1.40 $ 
 */
public class OverBoostM1 extends RandomizableIteratedSingleClassifierEnhancer
        implements WeightedInstancesHandler, Sourcable, TechnicalInformationHandler {

    /** for serialization */
    static final long serialVersionUID = -7378107808933117974L;

    /** Max num iterations tried to find classifier with non-zero error. */
    private static int MAX_NUM_RESAMPLING_ITERATIONS = 10;

    /** Array for storing the weights for the votes. */
    protected double[] m_Betas;

    /** The number of successfully generated base classifiers. */
    protected int m_NumIterationsPerformed;

    /** Weight Threshold. The percentage of weight mass used in training */
    protected int m_WeightThreshold = 100;

    /** Use boosting with reweighting? */
    protected boolean m_UseResampling;

    /** The number of classes */
    protected int m_NumClasses;

    /** a ZeroR model in case no model can be built from the data */
    protected Classifier m_ZeroR;

    /**
     * Constructor.
     */
    public OverBoostM1() {

        m_Classifier = new weka.classifiers.trees.DecisionStump();
    }

    /**
     * Returns a string describing classifier
     * @return a description suitable for
     * displaying in the explorer/experimenter gui
     */
    public String globalInfo() {

        return "Class for boosting a nominal class classifier using the Adaboost "
                + "M1 method. Only nominal class problems can be tackled. Often "
                + "dramatically improves performance, but sometimes overfits.\n\n" + "For more information, see\n\n"
                + getTechnicalInformation().toString();
    }

    /**
     * Returns an instance of a TechnicalInformation object, containing 
     * detailed information about the technical background of this class,
     * e.g., paper reference or book this class is based on.
     * 
     * @return the technical information about this class
     */
    public TechnicalInformation getTechnicalInformation() {
        TechnicalInformation result;

        result = new TechnicalInformation(Type.INPROCEEDINGS);
        result.setValue(Field.AUTHOR, "Yoav Freund and Robert E. Schapire");
        result.setValue(Field.TITLE, "Experiments with a new boosting algorithm");
        result.setValue(Field.BOOKTITLE, "Thirteenth International Conference on Machine Learning");
        result.setValue(Field.YEAR, "1996");
        result.setValue(Field.PAGES, "148-156");
        result.setValue(Field.PUBLISHER, "Morgan Kaufmann");
        result.setValue(Field.ADDRESS, "San Francisco");

        return result;
    }

    /**
     * String describing default classifier.
     * 
     * @return the default classifier classname
     */
    protected String defaultClassifierString() {

        return "weka.classifiers.trees.DecisionStump";
    }

    /**
     * Select only instances with weights that contribute to 
     * the specified quantile of the weight distribution
     *
     * @param data the input instances
     * @param quantile the specified quantile eg 0.9 to select 
     * 90% of the weight mass
     * @return the selected instances
     */
    protected Instances selectWeightQuantile(Instances data, double quantile) {

        int numInstances = data.numInstances();
        Instances trainData = new Instances(data, numInstances);
        double[] weights = new double[numInstances];

        double sumOfWeights = 0;
        for (int i = 0; i < numInstances; i++) {
            weights[i] = data.instance(i).weight();
            sumOfWeights += weights[i];
        }
        double weightMassToSelect = sumOfWeights * quantile;
        int[] sortedIndices = Utils.sort(weights);

        // Select the instances
        sumOfWeights = 0;
        for (int i = numInstances - 1; i >= 0; i--) {
            Instance instance = (Instance) data.instance(sortedIndices[i]).copy();
            trainData.add(instance);
            sumOfWeights += weights[sortedIndices[i]];
            if ((sumOfWeights > weightMassToSelect) && (i > 0)
                    && (weights[sortedIndices[i]] != weights[sortedIndices[i - 1]])) {
                break;
            }
        }
        if (m_Debug) {
            System.err.println("Selected " + trainData.numInstances() + " out of " + numInstances);
        }
        return trainData;
    }

    /**
     * Returns an enumeration describing the available options.
     *
     * @return an enumeration of all the available options.
     */
    public Enumeration listOptions() {

        Vector newVector = new Vector();

        newVector.addElement(new Option("\tPercentage of weight mass to base training on.\n"
                + "\t(default 100, reduce to around 90 speed up)", "P", 1, "-P <num>"));

        newVector.addElement(new Option("\tUse resampling for boosting.", "Q", 0, "-Q"));

        Enumeration enu = super.listOptions();
        while (enu.hasMoreElements()) {
            newVector.addElement(enu.nextElement());
        }

        return newVector.elements();
    }

    /**
     * Parses a given list of options. <p/>
     *
     <!-- options-start -->
     * Valid options are: <p/>
     * 
     * <pre> -P &lt;num&gt;
     *  Percentage of weight mass to base training on.
     *  (default 100, reduce to around 90 speed up)</pre>
     * 
     * <pre> -Q
     *  Use resampling for boosting.</pre>
     * 
     * <pre> -S &lt;num&gt;
     *  Random number seed.
     *  (default 1)</pre>
     * 
     * <pre> -I &lt;num&gt;
     *  Number of iterations.
     *  (default 10)</pre>
     * 
     * <pre> -D
     *  If set, classifier is run in debug mode and
     *  may output additional info to the console</pre>
     * 
     * <pre> -W
     *  Full name of base classifier.
     *  (default: weka.classifiers.trees.DecisionStump)</pre>
     * 
     * <pre> 
     * Options specific to classifier weka.classifiers.trees.DecisionStump:
     * </pre>
     * 
     * <pre> -D
     *  If set, classifier is run in debug mode and
     *  may output additional info to the console</pre>
     * 
     <!-- options-end -->
     *
     * Options after -- are passed to the designated classifier.<p>
     *
     * @param options the list of options as an array of strings
     * @throws Exception if an option is not supported
     */
    public void setOptions(String[] options) throws Exception {

        String thresholdString = Utils.getOption('P', options);
        if (thresholdString.length() != 0) {
            setWeightThreshold(Integer.parseInt(thresholdString));
        } else {
            setWeightThreshold(100);
        }

        setUseResampling(Utils.getFlag('Q', options));

        super.setOptions(options);
    }

    /**
     * Gets the current settings of the Classifier.
     *
     * @return an array of strings suitable for passing to setOptions
     */
    public String[] getOptions() {
        Vector result;
        String[] options;
        int i;

        result = new Vector();

        if (getUseResampling())
            result.add("-Q");

        result.add("-P");
        result.add("" + getWeightThreshold());

        options = super.getOptions();
        for (i = 0; i < options.length; i++)
            result.add(options[i]);

        return (String[]) result.toArray(new String[result.size()]);
    }

    /**
     * Returns the tip text for this property
     * @return tip text for this property suitable for
     * displaying in the explorer/experimenter gui
     */
    public String weightThresholdTipText() {
        return "Weight threshold for weight pruning.";
    }

    /**
     * Set weight threshold
     *
     * @param threshold the percentage of weight mass used for training
     */
    public void setWeightThreshold(int threshold) {

        m_WeightThreshold = threshold;
    }

    /**
     * Get the degree of weight thresholding
     *
     * @return the percentage of weight mass used for training
     */
    public int getWeightThreshold() {

        return m_WeightThreshold;
    }

    /**
     * Returns the tip text for this property
     * @return tip text for this property suitable for
     * displaying in the explorer/experimenter gui
     */
    public String useResamplingTipText() {
        return "Whether resampling is used instead of reweighting.";
    }

    /**
     * Set resampling mode
     *
     * @param r true if resampling should be done
     */
    public void setUseResampling(boolean r) {

        m_UseResampling = r;
    }

    /**
     * Get whether resampling is turned on
     *
     * @return true if resampling output is on
     */
    public boolean getUseResampling() {

        return m_UseResampling;
    }

    /**
     * Returns default capabilities of the classifier.
     *
     * @return      the capabilities of this classifier
     */
    public Capabilities getCapabilities() {
        Capabilities result = super.getCapabilities();

        // class
        result.disableAllClasses();
        result.disableAllClassDependencies();
        if (super.getCapabilities().handles(Capability.NOMINAL_CLASS))
            result.enable(Capability.NOMINAL_CLASS);
        if (super.getCapabilities().handles(Capability.BINARY_CLASS))
            result.enable(Capability.BINARY_CLASS);

        return result;
    }

    /**
     * Boosting method.
     *
     * @param data the training data to be used for generating the
     * boosted classifier.
     * @throws Exception if the classifier could not be built successfully
     */

    public void buildClassifier(Instances data) throws Exception {

        super.buildClassifier(data);

        // can classifier handle the data?
        getCapabilities().testWithFail(data);

        // remove instances with missing class
        data = new Instances(data);
        data.deleteWithMissingClass();

        // only class? -> build ZeroR model
        if (data.numAttributes() == 1) {
            System.err.println(
                    "Cannot build model (only class attribute present in data!), " + "using ZeroR model instead!");
            m_ZeroR = new weka.classifiers.rules.ZeroR();
            m_ZeroR.buildClassifier(data);
            return;
        } else {
            m_ZeroR = null;
        }

        m_NumClasses = data.numClasses();
        if (m_NumClasses != 2)
            System.err.println("Can only build model for binary class data");

        /*
        we do not use the method buildClassifierWithWeights
         as we think that some base learning algorithms could 
         not deal with weighted data.
         */
        buildClassifierUsingResampling(data);
    }

    /**
     * 
     * nMajnMin
     * @param data
     * @param i
     * @return
     */
    protected Instances randomSampling(Instances copia, int majC, int minC, int nMaj, int nMin,
            Random simplingRandom) {
        int[] majExamples = new int[copia.numInstances()];
        int[] minExamples = new int[copia.numInstances()];
        int majCount = 0, minCount = 0;
        // First, we copy the examples from the minority class and save the indexes of the majority
        // the new data-set contains samples_min + samples_min * N / 100
        int size = nMaj + nMin;
        //selected = new int[size]; // we store the selected examples indexes

        String majClassName = copia.attribute(copia.classIndex()).value(majC);

        Instances myDataset = new Instances(copia, 0);
        int nData = 0;
        for (int i = 0; i < copia.numInstances(); i++) {
            if (copia.instance(i).stringValue(copia.classIndex()).equalsIgnoreCase(majClassName)) {
                // save index
                majExamples[majCount] = i;
                majCount++;
            } else {
                minExamples[minCount] = i;
                minCount++;
            }
        }
        if (minCount <= 0)
            return copia;
        /* random undersampling of the majority */
        //boolean[] taken = new boolean[copia.numInstances()];
        int r;
        if (nMaj == majCount) {
            //System.out.println("#equal");
            for (int i = 0; i < nMaj; i++) {
                myDataset.add(copia.instance(majExamples[i]));
            }
        } else {
            for (int i = 0; i < nMaj; i++) {
                r = simplingRandom.nextInt(majCount);
                //selected[nData] = majExamples[r];
                myDataset.add(copia.instance(majExamples[r]));
                //taken[majExamples[r]] = true;
            }
        }
        for (int i = 0; i < nMin; i++) {
            r = simplingRandom.nextInt(minCount);
            //System.out.print("_"+r);

            //selected[nData] = minExamples[r];
            myDataset.add(copia.instance(minExamples[r]));
            //taken[minExamples[r]] = true;
        }

        //System.out.println();
        //System.out.println("minC="+minCount+"; majC="+majCount);

        myDataset.randomize(simplingRandom);
        return myDataset;
    }

    /**
     * Boosting method. Boosts using resampling
     *
     * @param data the training data to be used for generating the
     * boosted classifier.
     * @throws Exception if the classifier could not be built successfully
     */
    protected void buildClassifierUsingResampling(Instances data) throws Exception {

        Instances trainData, sample, training;
        double epsilon, reweight, sumProbs;
        Evaluation evaluation;
        int numInstances = data.numInstances();
        Random randomInstance = new Random(m_Seed);
        int resamplingIterations = 0;

        // Initialize data
        m_Betas = new double[m_Classifiers.length];
        m_NumIterationsPerformed = 0;
        // Create a copy of the data so that when the weights are diddled
        // with it doesn't mess up the weights for anyone else
        training = new Instances(data, 0, numInstances);
        sumProbs = training.sumOfWeights();
        for (int i = 0; i < training.numInstances(); i++) {
            training.instance(i).setWeight(training.instance(i).weight() / sumProbs);
        }

        // Do boostrap iterations
        for (m_NumIterationsPerformed = 0; m_NumIterationsPerformed < m_Classifiers.length; m_NumIterationsPerformed++) {
            if (m_Debug) {
                System.err.println("Training classifier " + (m_NumIterationsPerformed + 1));
            }

            // Select instances to train the classifier on
            if (m_WeightThreshold < 100) {
                trainData = selectWeightQuantile(training, (double) m_WeightThreshold / 100);
            } else {
                trainData = new Instances(training);
            }

            // Resample
            resamplingIterations = 0;
            double[] weights = new double[trainData.numInstances()];
            for (int i = 0; i < weights.length; i++) {
                weights[i] = trainData.instance(i).weight();
            }
            do {
                sample = trainData.resampleWithWeights(randomInstance, weights);

                //
                int classNum[] = sample.attributeStats(sample.classIndex()).nominalCounts;
                int minC, nMin = classNum[0];
                int majC, nMaj = classNum[1];
                if (nMin < nMaj) {
                    minC = 0;
                    majC = 1;
                } else {
                    minC = 1;
                    majC = 0;
                    nMin = classNum[1];
                    nMaj = classNum[0];
                }
                //System.out.println("minC="+nMin+"; majC="+nMaj);
                /*
                 * balance the data which boosting generate for training base classifier
                */
                //System.out.println("before:"+classNum[0]+"-"+classNum[1]);
                Instances sampleData = randomSampling(sample, majC, minC, nMaj, nMaj, randomInstance);
                //classNum =sampleData.attributeStats(sampleData.classIndex()).nominalCounts;
                //System.out.println("after:"+classNum[0]+"-"+classNum[1]);

                // Build and evaluate classifier
                m_Classifiers[m_NumIterationsPerformed].buildClassifier(sampleData);

                evaluation = new Evaluation(data);
                evaluation.evaluateModel(m_Classifiers[m_NumIterationsPerformed], training);
                epsilon = evaluation.errorRate();
                resamplingIterations++;
            } while (Utils.eq(epsilon, 0) && (resamplingIterations < MAX_NUM_RESAMPLING_ITERATIONS));

            // Stop if error too big or 0
            if (Utils.grOrEq(epsilon, 0.5) || Utils.eq(epsilon, 0)) {
                if (m_NumIterationsPerformed == 0) {
                    m_NumIterationsPerformed = 1; // If we're the first we have to to use it
                }
                break;
            }

            // Determine the weight to assign to this model
            m_Betas[m_NumIterationsPerformed] = Math.log((1 - epsilon) / epsilon);
            reweight = (1 - epsilon) / epsilon;
            if (m_Debug) {
                System.err.println("\terror rate = " + epsilon + "  beta = " + m_Betas[m_NumIterationsPerformed]);
            }

            // Update instance weights
            setWeights(training, reweight);
        }
    }

    /**
     * Sets the weights for the next iteration.
     * 
     * @param training the training instances
     * @param reweight the reweighting factor
     * @throws Exception if something goes wrong
     */
    protected void setWeights(Instances training, double reweight) throws Exception {

        double oldSumOfWeights, newSumOfWeights;

        oldSumOfWeights = training.sumOfWeights();
        Enumeration enu = training.enumerateInstances();
        while (enu.hasMoreElements()) {
            Instance instance = (Instance) enu.nextElement();
            if (!Utils.eq(m_Classifiers[m_NumIterationsPerformed].classifyInstance(instance),
                    instance.classValue()))
                instance.setWeight(instance.weight() * reweight);
        }

        // Renormalize weights
        newSumOfWeights = training.sumOfWeights();
        enu = training.enumerateInstances();
        while (enu.hasMoreElements()) {
            Instance instance = (Instance) enu.nextElement();
            instance.setWeight(instance.weight() * oldSumOfWeights / newSumOfWeights);
        }
    }

    /**
     * Boosting method. Boosts any classifier that can handle weighted
     * instances.
     *
     * @param data the training data to be used for generating the
     * boosted classifier.
     * @throws Exception if the classifier could not be built successfully
     */
    protected void buildClassifierWithWeights(Instances data) throws Exception {

        Instances trainData, training;
        double epsilon, reweight;
        Evaluation evaluation;
        int numInstances = data.numInstances();
        Random randomInstance = new Random(m_Seed);

        // Initialize data
        m_Betas = new double[m_Classifiers.length];
        m_NumIterationsPerformed = 0;

        // Create a copy of the data so that when the weights are diddled
        // with it doesn't mess up the weights for anyone else
        training = new Instances(data, 0, numInstances);

        // Do boostrap iterations
        for (m_NumIterationsPerformed = 0; m_NumIterationsPerformed < m_Classifiers.length; m_NumIterationsPerformed++) {
            if (m_Debug) {
                System.err.println("Training classifier " + (m_NumIterationsPerformed + 1));
            }
            // Select instances to train the classifier on
            if (m_WeightThreshold < 100) {
                trainData = selectWeightQuantile(training, (double) m_WeightThreshold / 100);
            } else {
                trainData = new Instances(training, 0, numInstances);
            }

            // Build the classifier
            if (m_Classifiers[m_NumIterationsPerformed] instanceof Randomizable)
                ((Randomizable) m_Classifiers[m_NumIterationsPerformed]).setSeed(randomInstance.nextInt());

            // this is the training data for building base classifier, 
            m_Classifiers[m_NumIterationsPerformed].buildClassifier(trainData);

            // Evaluate the classifier
            evaluation = new Evaluation(data);
            evaluation.evaluateModel(m_Classifiers[m_NumIterationsPerformed], training);
            epsilon = evaluation.errorRate();

            // Stop if error too small or error too big and ignore this model
            if (Utils.grOrEq(epsilon, 0.5) || Utils.eq(epsilon, 0)) {
                if (m_NumIterationsPerformed == 0) {
                    m_NumIterationsPerformed = 1; // If we're the first we have to to use it
                }
                break;
            }
            // Determine the weight to assign to this model
            m_Betas[m_NumIterationsPerformed] = Math.log((1 - epsilon) / epsilon);
            reweight = (1 - epsilon) / epsilon;
            if (m_Debug) {
                System.err.println("\terror rate = " + epsilon + "  beta = " + m_Betas[m_NumIterationsPerformed]);
            }

            // Update instance weights
            setWeights(training, reweight);
        }
    }

    /**
     * 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 instance could not be classified
     * successfully
     */
    public double[] distributionForInstance(Instance instance) throws Exception {

        // default model?
        if (m_ZeroR != null) {
            return m_ZeroR.distributionForInstance(instance);
        }

        if (m_NumIterationsPerformed == 0) {
            throw new Exception("No model built");
        }
        double[] sums = new double[instance.numClasses()];

        if (m_NumIterationsPerformed == 1) {
            return m_Classifiers[0].distributionForInstance(instance);
        } else {
            for (int i = 0; i < m_NumIterationsPerformed; i++) {
                sums[(int) m_Classifiers[i].classifyInstance(instance)] += m_Betas[i];
            }
            return Utils.logs2probs(sums);
        }
    }

    /**
     * Returns the boosted model as Java source code.
     *
     * @param className the classname of the generated class
     * @return the tree as Java source code
     * @throws Exception if something goes wrong
     */
    public String toSource(String className) throws Exception {

        if (m_NumIterationsPerformed == 0) {
            throw new Exception("No model built yet");
        }
        if (!(m_Classifiers[0] instanceof Sourcable)) {
            throw new Exception("Base learner " + m_Classifier.getClass().getName() + " is not Sourcable");
        }

        StringBuffer text = new StringBuffer("class ");
        text.append(className).append(" {\n\n");

        text.append("  public static double classify(Object[] i) {\n");

        if (m_NumIterationsPerformed == 1) {
            text.append("    return " + className + "_0.classify(i);\n");
        } else {
            text.append("    double [] sums = new double [" + m_NumClasses + "];\n");
            for (int i = 0; i < m_NumIterationsPerformed; i++) {
                text.append("    sums[(int) " + className + '_' + i + ".classify(i)] += " + m_Betas[i] + ";\n");
            }
            text.append("    double maxV = sums[0];\n" + "    int maxI = 0;\n" + "    for (int j = 1; j < "
                    + m_NumClasses + "; j++) {\n" + "      if (sums[j] > maxV) { maxV = sums[j]; maxI = j; }\n"
                    + "    }\n    return (double) maxI;\n");
        }
        text.append("  }\n}\n");

        for (int i = 0; i < m_Classifiers.length; i++) {
            text.append(((Sourcable) m_Classifiers[i]).toSource(className + '_' + i));
        }
        return text.toString();
    }

    /**
     * Returns description of the boosted classifier.
     *
     * @return description of the boosted classifier as a string
     */
    public String toString() {

        // only ZeroR model?
        if (m_ZeroR != null) {
            StringBuffer buf = new StringBuffer();
            buf.append(this.getClass().getName().replaceAll(".*\\.", "") + "\n");
            buf.append(this.getClass().getName().replaceAll(".*\\.", "").replaceAll(".", "=") + "\n\n");
            buf.append("Warning: No model could be built, hence ZeroR model is used:\n\n");
            buf.append(m_ZeroR.toString());
            return buf.toString();
        }

        StringBuffer text = new StringBuffer();

        if (m_NumIterationsPerformed == 0) {
            text.append("AdaBoostM1: No model built yet.\n");
        } else if (m_NumIterationsPerformed == 1) {
            text.append("AdaBoostM1: No boosting possible, one classifier used!\n");
            text.append(m_Classifiers[0].toString() + "\n");
        } else {
            text.append("AdaBoostM1: Base classifiers and their weights: \n\n");
            for (int i = 0; i < m_NumIterationsPerformed; i++) {
                text.append(m_Classifiers[i].toString() + "\n\n");
                text.append("Weight: " + Utils.roundDouble(m_Betas[i], 2) + "\n\n");
            }
            text.append("Number of performed Iterations: " + m_NumIterationsPerformed + "\n");
        }

        return text.toString();
    }

    /**
     * Returns the revision string.
     * 
     * @return      the revision
     */
    public String getRevision() {
        return RevisionUtils.extract("$Revision: 1.40 $");
    }

    /**
     * Main method for testing this class.
     *
     * @param argv the options
     */
    public static void main(String[] argv) {
        runClassifier(new OverBoostM1(), argv);
    }
}