weka.classifiers.meta

## Class Bagging

- java.lang.Object
- - weka.classifiers.AbstractClassifier
  - - weka.classifiers.SingleClassifierEnhancer
    - - weka.classifiers.IteratedSingleClassifierEnhancer
      - - weka.classifiers.ParallelIteratedSingleClassifierEnhancer
        - - weka.classifiers.RandomizableParallelIteratedSingleClassifierEnhancer
          - - weka.classifiers.meta.Bagging

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, Classifier, AdditionalMeasureProducer, Aggregateable<Bagging>, CapabilitiesHandler, CapabilitiesIgnorer, OptionHandler, PartitionGenerator, Randomizable, RevisionHandler, TechnicalInformationHandler, WeightedInstancesHandler

      public class Bagging
      extends RandomizableParallelIteratedSingleClassifierEnhancer
      implements WeightedInstancesHandler, AdditionalMeasureProducer, TechnicalInformationHandler, PartitionGenerator, Aggregateable<Bagging>

  Class for bagging a classifier to reduce variance. Can do classification and regression depending on the base learner.
  For more information, see
  Leo Breiman (1996). Bagging predictors. Machine Learning. 24(2):123-140.

  BibTeX:

       @article{Breiman1996,
          author = {Leo Breiman},
          journal = {Machine Learning},
          number = {2},
          pages = {123-140},
          title = {Bagging predictors},
          volume = {24},
          year = {1996}
       }

  Valid options are:

       -P
        Size of each bag, as a percentage of the
        training set size. (default 100)

       -O
        Calculate the out of bag error.

       -represent-copies-using-weights
        Represent copies of instances using weights rather than explicitly.

       -S <num>
        Random number seed.
        (default 1)

       -num-slots <num>
        Number of execution slots.
        (default 1 - i.e. no parallelism)

       -I <num>
        Number of iterations.
        (default 10)

       -D
        If set, classifier is run in debug mode and
        may output additional info to the console

       -W
        Full name of base classifier.
        (default: weka.classifiers.trees.REPTree)

       Options specific to classifier weka.classifiers.trees.REPTree:

       -M <minimum number of instances>
        Set minimum number of instances per leaf (default 2).

       -V <minimum variance for split>
        Set minimum numeric class variance proportion
        of train variance for split (default 1e-3).

       -N <number of folds>
        Number of folds for reduced error pruning (default 3).

       -S <seed>
        Seed for random data shuffling (default 1).

       -P
        No pruning.

       -L
        Maximum tree depth (default -1, no maximum)

       -I
        Initial class value count (default 0)

       -R
        Spread initial count over all class values (i.e. don't use 1 per value)

  Options after -- are passed to the designated classifier.

  Version:
    $Revision: 10470 $
  Author:
    Eibe Frank (eibe@cs.waikato.ac.nz), Len Trigg (len@reeltwo.com), Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Bagging()` Constructor.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Bagging` | `aggregate(Bagging toAggregate)` Aggregate an object with this one
    `java.lang.String` | `bagSizePercentTipText()` Returns the tip text for this property
    `void` | `buildClassifier(Instances data)` Bagging method.
    `java.lang.String` | `calcOutOfBagTipText()` Returns the tip text for this property
    `double[]` | `distributionForInstance(Instance instance)` Calculates the class membership probabilities for the given test instance.
    `java.util.Enumeration<java.lang.String>` | `enumerateMeasures()` Returns an enumeration of the additional measure names.
    `void` | `finalizeAggregation()` Call to complete the aggregation process.
    `void` | `generatePartition(Instances data)` Builds the classifier to generate a partition.
    `int` | `getBagSizePercent()` Gets the size of each bag, as a percentage of the training set size.
    `boolean` | `getCalcOutOfBag()` Get whether the out of bag error is calculated.
    `double` | `getMeasure(java.lang.String additionalMeasureName)` Returns the value of the named measure.
    `double[]` | `getMembershipValues(Instance inst)` Computes an array that indicates leaf membership
    `java.lang.String[]` | `getOptions()` Gets the current settings of the Classifier.
    `boolean` | `getRepresentCopiesUsingWeights()` Get whether copies of instances are represented using weights rather than explicitly.
    `java.lang.String` | `getRevision()` Returns the revision string.
    `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.
    `java.lang.String` | `globalInfo()` Returns a string describing classifier
    `java.util.Enumeration<Option>` | `listOptions()` Returns an enumeration describing the available options.
    `static void` | `main(java.lang.String[] argv)` Main method for testing this class.
    `double` | `measureOutOfBagError()` Gets the out of bag error that was calculated as the classifier was built.
    `int` | `numElements()` Returns the number of elements in the partition.
    `java.lang.String` | `representCopiesUsingWeightsTipText()` Returns the tip text for this property
    `void` | `setBagSizePercent(int newBagSizePercent)` Sets the size of each bag, as a percentage of the training set size.
    `void` | `setCalcOutOfBag(boolean calcOutOfBag)` Set whether the out of bag error is calculated.
    `void` | `setOptions(java.lang.String[] options)` Parses a given list of options.
    `void` | `setRepresentCopiesUsingWeights(boolean representUsingWeights)` Set whether copies of instances are represented using weights rather than explicitly.
    `java.lang.String` | `toString()` Returns description of the bagged classifier.

    - ### Methods inherited from class weka.classifiers.RandomizableParallelIteratedSingleClassifierEnhancer

      `getSeed, seedTipText, setSeed`

    - ### Methods inherited from class weka.classifiers.ParallelIteratedSingleClassifierEnhancer

      `getNumExecutionSlots, numExecutionSlotsTipText, setNumExecutionSlots`

    - ### Methods inherited from class weka.classifiers.IteratedSingleClassifierEnhancer

      `getNumIterations, numIterationsTipText, setNumIterations`

    - ### Methods inherited from class weka.classifiers.SingleClassifierEnhancer

      `classifierTipText, getCapabilities, getClassifier, setClassifier`

    - ### Methods inherited from class weka.classifiers.AbstractClassifier

      `classifyInstance, debugTipText, doNotCheckCapabilitiesTipText, forName, getDebug, getDoNotCheckCapabilities, makeCopies, makeCopy, runClassifier, setDebug, setDoNotCheckCapabilities`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface weka.core.CapabilitiesHandler

      `getCapabilities`

- - ### Constructor Detail

    - #### Bagging

          public Bagging()

      Constructor.

  - ### Method Detail

    - #### globalInfo

          public java.lang.String globalInfo()

      Returns a string describing classifier
      Returns:
        a description suitable for displaying in the explorer/experimenter gui

    - #### 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

    - #### listOptions

          public java.util.Enumeration<Option> listOptions()

      Returns an enumeration describing the available options.
      Specified by:
        `listOptions` in interface `OptionHandler`
      Overrides:
        `listOptions` in class `RandomizableParallelIteratedSingleClassifierEnhancer`
      Returns:
        an enumeration of all the available options.

    - #### setOptions

          public void setOptions(java.lang.String[] options)
                          throws java.lang.Exception

      Parses a given list of options.

      Valid options are:

           -P
            Size of each bag, as a percentage of the
            training set size. (default 100)

           -O
            Calculate the out of bag error.

           -represent-copies-using-weights
            Represent copies of instances using weights rather than explicitly.

           -S <num>
            Random number seed.
            (default 1)

           -num-slots <num>
            Number of execution slots.
            (default 1 - i.e. no parallelism)

           -I <num>
            Number of iterations.
            (default 10)

           -D
            If set, classifier is run in debug mode and
            may output additional info to the console

           -W
            Full name of base classifier.
            (default: weka.classifiers.trees.REPTree)

           Options specific to classifier weka.classifiers.trees.REPTree:

           -M <minimum number of instances>
            Set minimum number of instances per leaf (default 2).

           -V <minimum variance for split>
            Set minimum numeric class variance proportion
            of train variance for split (default 1e-3).

           -N <number of folds>
            Number of folds for reduced error pruning (default 3).

           -S <seed>
            Seed for random data shuffling (default 1).

           -P
            No pruning.

           -L
            Maximum tree depth (default -1, no maximum)

           -I
            Initial class value count (default 0)

           -R
            Spread initial count over all class values (i.e. don't use 1 per value)

      Options after -- are passed to the designated classifier.

      Specified by:
        `setOptions` in interface `OptionHandler`
      Overrides:
        `setOptions` in class `RandomizableParallelIteratedSingleClassifierEnhancer`
      Parameters:
        `options` - the list of options as an array of strings
      Throws:
        `java.lang.Exception` - if an option is not supported

    - #### getOptions

          public java.lang.String[] getOptions()

      Gets the current settings of the Classifier.
      Specified by:
        `getOptions` in interface `OptionHandler`
      Overrides:
        `getOptions` in class `RandomizableParallelIteratedSingleClassifierEnhancer`
      Returns:
        an array of strings suitable for passing to setOptions

    - #### bagSizePercentTipText

          public java.lang.String bagSizePercentTipText()

      Returns the tip text for this property
      Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

    - #### getBagSizePercent

          public int getBagSizePercent()

      Gets the size of each bag, as a percentage of the training set size.
      Returns:
        the bag size, as a percentage.

    - #### setBagSizePercent

          public void setBagSizePercent(int newBagSizePercent)

      Sets the size of each bag, as a percentage of the training set size.
      Parameters:
        `newBagSizePercent` - the bag size, as a percentage.

    - #### representCopiesUsingWeightsTipText

          public java.lang.String representCopiesUsingWeightsTipText()

      Returns the tip text for this property
      Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

    - #### setRepresentCopiesUsingWeights

          public void setRepresentCopiesUsingWeights(boolean representUsingWeights)

      Set whether copies of instances are represented using weights rather than explicitly.
      Parameters:
        `representUsingWeights` - whether to represent copies using weights

    - #### getRepresentCopiesUsingWeights

          public boolean getRepresentCopiesUsingWeights()

      Get whether copies of instances are represented using weights rather than explicitly.
      Returns:
        whether the out of bag error is calculated

    - #### calcOutOfBagTipText

          public java.lang.String calcOutOfBagTipText()

      Returns the tip text for this property
      Returns:
        tip text for this property suitable for displaying in the explorer/experimenter gui

    - #### setCalcOutOfBag

          public void setCalcOutOfBag(boolean calcOutOfBag)

      Set whether the out of bag error is calculated.
      Parameters:
        `calcOutOfBag` - whether to calculate the out of bag error

    - #### getCalcOutOfBag

          public boolean getCalcOutOfBag()

      Get whether the out of bag error is calculated.
      Returns:
        whether the out of bag error is calculated

    - #### measureOutOfBagError

          public double measureOutOfBagError()

      Gets the out of bag error that was calculated as the classifier was built.
      Returns:
        the out of bag error

    - #### enumerateMeasures

          public java.util.Enumeration<java.lang.String> enumerateMeasures()

      Returns an enumeration of the additional measure names.
      Specified by:
        `enumerateMeasures` in interface `AdditionalMeasureProducer`
      Returns:
        an enumeration of the measure names

    - #### getMeasure

          public double getMeasure(java.lang.String additionalMeasureName)

      Returns the value of the named measure.
      Specified by:
        `getMeasure` in interface `AdditionalMeasureProducer`
      Parameters:
        `additionalMeasureName` - the name of the measure to query for its value
      Returns:
        the value of the named measure
      Throws:
        `java.lang.IllegalArgumentException` - if the named measure is not supported

    - #### buildClassifier

          public void buildClassifier(Instances data)
                               throws java.lang.Exception

      Bagging method.
      Specified by:
        `buildClassifier` in interface `Classifier`
      Overrides:
        `buildClassifier` in class `ParallelIteratedSingleClassifierEnhancer`
      Parameters:
        `data` - the training data to be used for generating the bagged classifier.
      Throws:
        `java.lang.Exception` - if the classifier could not be built successfully

    - #### distributionForInstance

          public double[] distributionForInstance(Instance instance)
                                           throws java.lang.Exception

      Calculates the class membership probabilities for the given test instance.
      Specified by:
        `distributionForInstance` in interface `Classifier`
      Overrides:
        `distributionForInstance` in class `AbstractClassifier`
      Parameters:
        `instance` - the instance to be classified
      Returns:
        preedicted class probability distribution
      Throws:
        `java.lang.Exception` - if distribution can't be computed successfully

    - #### toString

          public java.lang.String toString()

      Returns description of the bagged classifier.
      Overrides:
        `toString` in class `java.lang.Object`
      Returns:
        description of the bagged classifier as a string

    - #### generatePartition

          public void generatePartition(Instances data)
                                 throws java.lang.Exception

      Builds the classifier to generate a partition.
      Specified by:
        `generatePartition` in interface `PartitionGenerator`
      Throws:
        `java.lang.Exception`

    - #### getMembershipValues

          public double[] getMembershipValues(Instance inst)
                                       throws java.lang.Exception

      Computes an array that indicates leaf membership
      Specified by:
        `getMembershipValues` in interface `PartitionGenerator`
      Throws:
        `java.lang.Exception`

    - #### numElements

          public int numElements()
                          throws java.lang.Exception

      Returns the number of elements in the partition.
      Specified by:
        `numElements` in interface `PartitionGenerator`
      Throws:
        `java.lang.Exception`

    - #### getRevision

          public java.lang.String getRevision()

      Returns the revision string.
      Specified by:
        `getRevision` in interface `RevisionHandler`
      Overrides:
        `getRevision` in class `AbstractClassifier`
      Returns:
        the revision

    - #### main

          public static void main(java.lang.String[] argv)

      Main method for testing this class.
      Parameters:
        `argv` - the options

    - #### aggregate

          public Bagging aggregate(Bagging toAggregate)
                            throws java.lang.Exception

      Aggregate an object with this one
      Specified by:
        `aggregate` in interface `Aggregateable<Bagging>`
      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<Bagging>`
      Throws:
        `java.lang.Exception` - if the aggregation can't be finalized for some reason