Package weka.classifiers.meta

Class Vote

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, Classifier, Aggregateable<Classifier>, BatchPredictor, CapabilitiesHandler, CapabilitiesIgnorer, CommandlineRunnable, EnvironmentHandler, OptionHandler, Randomizable, RevisionHandler, TechnicalInformationHandler, WeightedInstancesHandler
    public class Vote
extends RandomizableMultipleClassifiersCombiner
implements TechnicalInformationHandler, EnvironmentHandler, Aggregateable<Classifier>, WeightedInstancesHandler
    Class for combining classifiers. Different combinations of probability estimates for classification are available.

    For more information see:

    Ludmila I. Kuncheva (2004). Combining Pattern Classifiers: Methods and Algorithms. John Wiley and Sons, Inc..

    J. Kittler, M. Hatef, Robert P.W. Duin, J. Matas (1998). On combining classifiers. IEEE Transactions on Pattern Analysis and Machine Intelligence. 20(3):226-239.
    If a base classifier cannot handle instance weights, and the instance weights are not uniform, the data will be resampled with replacement based on the weights before being passed to that base classifier.

    Valid options are: 

     -P <path to serialized classifier>
  Full path to serialized classifier to include.
  May be specified multiple times to include
  multiple serialized classifiers. Note: it does
  not make sense to use pre-built classifiers in
  a cross-validation.
 
     -R <AVG|PROD|MAJ|MIN|MAX|MED>
  The combination rule to use
  (default: AVG)
 
     -print
  Print the individual models in the output
 
     -S <num>
  Random number seed.
  (default 1)
 
     -B <classifier specification>
  Full class name of classifier to include, followed
  by scheme options. May be specified multiple times.
  (default: "weka.classifiers.rules.ZeroR")
 
     -output-debug-info
  If set, classifier is run in debug mode and
  may output additional info to the console
 
     -do-not-check-capabilities
  If set, classifier capabilities are not checked before classifier is built
  (use with caution).
 
     Options specific to classifier weka.classifiers.rules.ZeroR:
 
     -output-debug-info
  If set, classifier is run in debug mode and
  may output additional info to the console
 
     -do-not-check-capabilities
  If set, classifier capabilities are not checked before classifier is built
  (use with caution).
    BibTeX: 
     @book{Kuncheva2004,
    author = {Ludmila I. Kuncheva},
    publisher = {John Wiley and Sons, Inc.},
    title = {Combining Pattern Classifiers: Methods and Algorithms},
    year = {2004}
 }
 
 @article{Kittler1998,
    author = {J. Kittler and M. Hatef and Robert P.W. Duin and J. Matas},
    journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
    number = {3},
    pages = {226-239},
    title = {On combining classifiers},
    volume = {20},
    year = {1998}
 }

    Version:
    $Revision: 15480 $
    Author:
    Alexander K. Seewald (alex@seewald.at), Eibe Frank (eibe@cs.waikato.ac.nz), Roberto Perdisci (roberto.perdisci@gmail.com)
    See Also:
    Serialized Form

    • Field Detail

      • AVERAGE_RULE

        public static final int AVERAGE_RULE
        combination rule: Average of Probabilities
        See Also:
        Constant Field Values

      • PRODUCT_RULE

        public static final int PRODUCT_RULE
        combination rule: Product of Probabilities (only nominal classes)
        See Also:
        Constant Field Values

      • MAJORITY_VOTING_RULE

        public static final int MAJORITY_VOTING_RULE
        combination rule: Majority Voting (only nominal classes)
        See Also:
        Constant Field Values

      • MIN_RULE

        public static final int MIN_RULE
        combination rule: Minimum Probability
        See Also:
        Constant Field Values

      • MAX_RULE

        public static final int MAX_RULE
        combination rule: Maximum Probability
        See Also:
        Constant Field Values

      • MEDIAN_RULE

        public static final int MEDIAN_RULE
        combination rule: Median Probability (only numeric class)
        See Also:
        Constant Field Values

      • TAGS_RULES

        public static final Tag[] TAGS_RULES
        combination rules

    • Constructor Detail

      • Vote

        public Vote()

    • Method Detail

      • globalInfo

        public java.lang.String globalInfo()
        Returns a string describing classifier
        Returns:
        a description suitable for displaying in the explorer/experimenter gui

      • setOptions

        public void setOptions​(java.lang.String[] options)
                throws java.lang.Exception
        Parses a given list of options.

        Valid options are: 

         -P <path to serialized classifier>
  Full path to serialized classifier to include.
  May be specified multiple times to include
  multiple serialized classifiers. Note: it does
  not make sense to use pre-built classifiers in
  a cross-validation.
 
         -R <AVG|PROD|MAJ|MIN|MAX|MED>
  The combination rule to use
  (default: AVG)
 
         -print
  Print the individual models in the output
 
         -S <num>
  Random number seed.
  (default 1)
 
         -B <classifier specification>
  Full class name of classifier to include, followed
  by scheme options. May be specified multiple times.
  (default: "weka.classifiers.rules.ZeroR")
 
         -output-debug-info
  If set, classifier is run in debug mode and
  may output additional info to the console
 
         -do-not-check-capabilities
  If set, classifier capabilities are not checked before classifier is built
  (use with caution).
 
         Options specific to classifier weka.classifiers.rules.ZeroR:
 
         -output-debug-info
  If set, classifier is run in debug mode and
  may output additional info to the console
 
         -do-not-check-capabilities
  If set, classifier capabilities are not checked before classifier is built
  (use with caution).
        Specified by:
        setOptions in interface OptionHandler
        Overrides:
        setOptions in class RandomizableMultipleClassifiersCombiner
        Parameters:
        options - the list of options as an array of strings
        Throws:
        java.lang.Exception - if an option is not supported

      • getTechnicalInformation

        public TechnicalInformation getTechnicalInformation()
        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.
        Specified by:
        getTechnicalInformation in interface TechnicalInformationHandler
        Returns:
        the technical information about this class

      • buildClassifier

        public void buildClassifier​(Instances data)
                     throws java.lang.Exception
        Builds all classifiers in the ensemble
        Specified by:
        buildClassifier in interface Classifier
        Parameters:
        data - the training data to be used for generating the ensemble.
        Throws:
        java.lang.Exception - if the classifier could not be built successfully

      • addPreBuiltClassifier

        public void addPreBuiltClassifier​(Classifier c)
        Add a prebuilt classifier to the list for use in the ensemble
        Parameters:
        c - a prebuilt Classifier to add.

      • removePreBuiltClassifier

        public void removePreBuiltClassifier​(Classifier c)
        Remove a prebuilt classifier from the list to use in the ensemble
        Parameters:
        c - the classifier to remove

      • classifyInstance

        public double classifyInstance​(Instance instance)
                        throws java.lang.Exception
        Classifies the given test instance.
        Specified by:
        classifyInstance in interface Classifier
        Overrides:
        classifyInstance in class AbstractClassifier
        Parameters:
        instance - the instance to be classified
        Returns:
        the predicted most likely class for the instance or Utils.missingValue() if no prediction is made
        Throws:
        java.lang.Exception - if an error occurred during the prediction

      • distributionForInstance

        public double[] distributionForInstance​(Instance instance)
                                 throws java.lang.Exception
        Classifies a given instance using the selected combination rule.
        Specified by:
        distributionForInstance in interface Classifier
        Overrides:
        distributionForInstance in class AbstractClassifier
        Parameters:
        instance - the instance to be classified
        Returns:
        the distribution
        Throws:
        java.lang.Exception - if instance could not be classified successfully

      • combinationRuleTipText

        public java.lang.String combinationRuleTipText()
        Returns the tip text for this property
        Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

      • getCombinationRule

        public SelectedTag getCombinationRule()
        Gets the combination rule used
        Returns:
        the combination rule used

      • setCombinationRule

        public void setCombinationRule​(SelectedTag newRule)
        Sets the combination rule to use. Values other than
        Parameters:
        newRule - the combination rule method to use

      • preBuiltClassifiersTipText

        public java.lang.String preBuiltClassifiersTipText()
        Returns the tip text for this property
        Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

      • setPreBuiltClassifiers

        public void setPreBuiltClassifiers​(java.io.File[] preBuilt)
        Set the paths to pre-built serialized classifiers to load and include in the ensemble
        Parameters:
        preBuilt - an array of File paths to serialized models

      • getPreBuiltClassifiers

        public java.io.File[] getPreBuiltClassifiers()
        Get the paths to pre-built serialized classifiers to load and include in the ensemble
        Returns:
        an array of File paths to serialized models

      • doNotPrintModelsTipText

        public java.lang.String doNotPrintModelsTipText()
        Returns the tip text for this property
        Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

      • setDoNotPrintModels

        public void setDoNotPrintModels​(boolean print)
        Set whether to print the individual ensemble models in the output
        Parameters:
        print - true if the individual models are to be printed

      • getDoNotPrintModels

        public boolean getDoNotPrintModels()
        Get whether to print the individual ensemble models in the output
        Returns:
        true if the individual models are to be printed

      • toString

        public java.lang.String toString()
        Output a representation of this classifier
        Overrides:
        toString in class java.lang.Object
        Returns:
        a string representation of the classifier

      • setEnvironment

        public void setEnvironment​(Environment env)
        Set environment variable values to substitute in the paths of serialized models to load
        Specified by:
        setEnvironment in interface EnvironmentHandler
        Parameters:
        env - the environment variables to use

      • aggregate

        public Classifier aggregate​(Classifier toAggregate)
                     throws java.lang.Exception
        Aggregate an object with this one
        Specified by:
        aggregate in interface Aggregateable<Classifier>
        Parameters:
        toAggregate - the object to aggregate
        Returns:
        the result of aggregation
        Throws:
        java.lang.Exception - if the supplied object can't be aggregated for some reason

      • finalizeAggregation

        public void finalizeAggregation()
                         throws java.lang.Exception
        Call to complete the aggregation process. Allows implementers to do any final processing based on how many objects were aggregated.
        Specified by:
        finalizeAggregation in interface Aggregateable<Classifier>
        Throws:
        java.lang.Exception - if the aggregation can't be finalized for some reason

      • main

        public static void main​(java.lang.String[] argv)
        Main method for testing this class.
        Parameters:
        argv - should contain the following arguments: -t training file [-T test file] [-c class index]