semisupdecorate.java

wekaUT是 university texas austin 开发的基于weka的半指导学习(semi supervised learning)的分类器

/*
 *    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.
 */

/*
 *    SemiSupDecorate.java
 *    WARNING: UNDER DEVELOPMENT
 *    Copyright (C) 2004 Prem Melville
 *    
 */

package weka.classifiers.meta;
import weka.classifiers.*;
import java.util.*;
import weka.core.*;
import weka.experiment.*;

/**
 * SemiSupDecorate is an attempt to exploit unlabeled data to improve Decorate.
 *
 * DECORATE is a meta-learner for building diverse ensembles of
 * classifiers by using specially constructed artificial training
 * examples. Comprehensive experiments have demonstrated that this
 * technique is consistently more accurate than the base classifier, 
 * Bagging and Random Forests. Decorate also obtains higher accuracy than
 * Boosting on small training sets, and achieves comparable performance
 * on larger training sets.  For more
 * details see: <p>
 *
 * Prem Melville and Raymond J. Mooney. <i>Constructing diverse
 * classifier ensembles using artificial training examples.</i>
 * Proceedings of the Seventeeth International Joint Conference on
 * Artificial Intelligence 2003.<p>
 *
 * Prem Melville and Raymond J. Mooney. <i>Creating diversity in ensembles using artificial data.</i>
 * Journal of Information Fusion.<BR><BR>
 *
 * Valid options are:<p>
 *
 * -D <br>
 * Turn on debugging output.<p>
 *
 * -W classname <br>
 * Specify the full class name of a weak classifier as the basis for 
 * SemiSupDecorate (default weka.classifiers.trees.j48.J48()).<p>
 *
 * -I num <br>
 * Specify the desired size of the committee (default 15). <p>
 *
 * -M iterations <br>
 * Set the maximum number of SemiSupDecorate iterations (default 50). <p>
 *
 * -S seed <br>
 * Seed for random number generator. (default 0).<p>
 *
 * -R factor <br>
 * Factor that determines number of artificial examples to generate. <p>
 *
 * Options after -- are passed to the designated classifier.<p>
 *
 * @author Prem Melville ([e-mail])
 * @version $Revision: 1.4 $ */
public class SemiSupDecorate extends EnsembleClassifier implements OptionHandler,SemiSupClassifier{

    /** Weight of unlabeled examples versus labeled examples */
    protected double m_Lambda = 1.0;
    
    /** Set of unlabeled examples */
    protected Instances m_Unlabeled;

    /** Set to true to use artificial data */
    protected boolean m_UseArtificial = true;
    
    /** Set to true to use unlabeled data */
    protected boolean m_UseUnlabeled = true; 
    //When set to false this should be equivalent to Decorate
    
    /** Types of unlabeled usage */
    static final int ALL = 0,
	IGNORE_LOW = 1,
	IGNORE_HIGH = 2,
	FLIP_LOW = 3;
    
    /** Type of usage of unlabeled examples */
    protected int m_UnlabeledMethod = ALL;
    
    /** Confidence threshold for labeling unlabeled examples */
    protected double m_Threshold = 0.9; 
    
    /** Set to true to get debugging output. */
    protected boolean m_Debug = false;

    /** The model base classifier to use. */
    protected Classifier m_Classifier = new weka.classifiers.trees.j48.J48();
      
    /** Vector of classifiers that make up the committee/ensemble. */
    protected Vector m_Committee = null;
    
    /** The desired ensemble size. */
    protected int m_DesiredSize = 15;

    /** The maximum number of SemiSupDecorate iterations to run. */
    protected int m_NumIterations = 50;
    
    /** The seed for random number generation. */
    protected int m_Seed = 0;
    
    /** Amount of artificial/random instances to use - specified as a
        fraction of the training data size. */
    protected double m_ArtSize = 1.0 ;

    /** The random number generator. */
    protected Random m_Random = new Random(0);
    
    /** Attribute statistics - used for generating artificial examples. */
    protected Vector m_AttributeStats = null;


    public void setLambda (double v) {
	m_Lambda = v;
    }

    public double getLambda () {
	return m_Lambda;
    }

    public String lambdaTipText() {
	return "set weight of unlabeled examples vs. labeled";
    }
    /**
     * Get the value of UseArtificial.
     * @return value of UseArtificial.
     */
    public boolean getUseArtificial() {
	return m_UseArtificial;
    }
    
    /**
     * Set the value of UseArtificial.
     * @param v  Value to assign to UseArtificial.
     */
    public void setUseArtificial(boolean  v) {
	m_UseArtificial = v;
    }
    
    /**
     * Get the value of Threshold.
     * @return value of Threshold.
     */
    public double getThreshold() {
	return m_Threshold;
    }
    
    /**
     * Set the value of Threshold.
     * @param v  Value to assign to Threshold.
     */
    public void setThreshold(double  v) {
	m_Threshold = v;
    }
    
    /**
     * Get the value of UnlabeledMethod.
     * @return value of UnlabeledMethod.
     */
    public int getUnlabeledMethod() {
	return m_UnlabeledMethod;
    }
    
    /**
     * Set the value of UnlabeledMethod.
     * @param v  Value to assign to UnlabeledMethod.
     */
    public void setUnlabeledMethod(int  v) {
	m_UnlabeledMethod = v;
    }
    
    /**
     * Get the value of UseUnlabeled.
     * @return value of UseUnlabeled.
     */
    public boolean getUseUnlabeled() {
	return m_UseUnlabeled;
    }
    
    /**
     * Set the value of UseUnlabeled.
     * @param v  Value to assign to UseUnlabeled.
     */
    public void setUseUnlabeled(boolean  v) {
	m_UseUnlabeled = v;
    }
    
    /**
     * Returns an enumeration describing the available options
     *
     * @return an enumeration of all the available options
     */
    public Enumeration listOptions() {
	Vector newVector = new Vector(8);
	newVector.addElement(new Option(
	      "\tTurn on debugging output.",
	      "D", 0, "-D"));
	newVector.addElement(new Option(
              "\tDesired size of ensemble.\n" 
              + "\t(default 15)",
              "I", 1, "-I"));
	newVector.addElement(new Option(
	      "\tMaximum number of SemiSupDecorate iterations.\n"
	      + "\t(default 50)",
	      "M", 1, "-M"));
	newVector.addElement(new Option(
	      "\tFull name of base classifier.\n"
	      + "\t(default weka.classifiers.trees.j48.J48)",
	      "W", 1, "-W"));
	newVector.addElement(new Option(
              "\tSeed for random number generator.\n"
	      +"\tIf set to -1, use a random seed.\n"
              + "\t(default 0)",
              "S", 1, "-S"));
	newVector.addElement(new Option(
				    "\tFactor that determines number of artificial examples to generate.\n"
				    +"\tSpecified proportional to training set size.\n" 
				    + "\t(default 1.0)",
				    "R", 1, "-R"));
    
	if ((m_Classifier != null) &&
	    (m_Classifier instanceof OptionHandler)) {
	    newVector.addElement(new Option(
					    "",
					    "", 0, "\nOptions specific to classifier "
					    + m_Classifier.getClass().getName() + ":"));
	    Enumeration enum = ((OptionHandler)m_Classifier).listOptions();
	    while (enum.hasMoreElements()) {
		newVector.addElement(enum.nextElement());
	    }
	}
	
	return newVector.elements();
    }

    
    /**
     * Parses a given list of options. Valid options are:<p>
     *   
     * -D <br>
     * Turn on debugging output.<p>
     *    
     * -W classname <br>
     * Specify the full class name of a weak classifier as the basis for 
     * SemiSupDecorate (required).<p>
     *
     * -I num <br>
     * Specify the desired size of the committee (default 15). <p>
     *
     * -M iterations <br>
     * Set the maximum number of SemiSupDecorate iterations (default 50). <p>
     *
     * -S seed <br>
     * Seed for random number generator. (default 0).<p>
     *
     * -R factor <br>
     * Factor that determines number of artificial examples to generate. <p>
     *
     * Options after -- are passed to the designated classifier.<p>
     *
     * @param options the list of options as an array of strings
     * @exception Exception if an option is not supported
     */
    public void setOptions(String[] options) throws Exception {
	setUseUnlabeled(Utils.getFlag('U', options));
	setUseArtificial(Utils.getFlag('A', options));
	setDebug(Utils.getFlag('D', options));

	String unlabeledMethod = Utils.getOption('Z', options);
	if (unlabeledMethod.length() != 0) {
	    setUnlabeledMethod(Integer.parseInt(unlabeledMethod));
	} else {
	    setUnlabeledMethod(0);
	}
	
	String threshold = Utils.getOption('T', options);
	if (threshold.length() != 0) {
	    setThreshold(Double.parseDouble(threshold));
	} else {
	    setThreshold(0.9);
	}
	
	String desiredSize = Utils.getOption('I', options);
	if (desiredSize.length() != 0) {
	    setDesiredSize(Integer.parseInt(desiredSize));
	} else {
	    setDesiredSize(15);
	}

	String maxIterations = Utils.getOption('M', options);
	if (maxIterations.length() != 0) {
	    setNumIterations(Integer.parseInt(maxIterations));
	} else {
	    setNumIterations(50);
	}
	
	String seed = Utils.getOption('S', options);
	if (seed.length() != 0) {
	    setSeed(Integer.parseInt(seed));
	} else {
	    setSeed(0);
	}
	
	String artSize = Utils.getOption('R', options);
	if (artSize.length() != 0) {
	    setArtificialSize(Double.parseDouble(artSize));
	} else {
	    setArtificialSize(1.0);
	}

	String lambda = Utils.getOption('L', options);
	if (lambda.length() != 0) {
	    setLambda(Double.parseDouble(lambda));
	}
	
	String classifierName = Utils.getOption('W', options);
	if (classifierName.length() == 0) {
	    throw new Exception("A classifier must be specified with"
				+ " the -W option.");
	}
	setClassifier(Classifier.forName(classifierName,
					 Utils.partitionOptions(options)));
    }
    
    /**
     * Gets the current settings of the Classifier.
     *
     * @return an array of strings suitable for passing to setOptions
     */
    public String [] getOptions() {
	String [] classifierOptions = new String [0];
	if ((m_Classifier != null) && 
	    (m_Classifier instanceof OptionHandler)) {
	    classifierOptions = ((OptionHandler)m_Classifier).getOptions();
	}
	String [] options = new String [classifierOptions.length + 19];
	int current = 0;
	if (getDebug()) {
	    options[current++] = "-D";
	}
	if (getUseUnlabeled()) {
	    options[current++] = "-U";