source: src/main/java/weka/classifiers/meta/RegressionByDiscretization.java @ 14

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

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

package weka.classifiers.meta;

import weka.classifiers.SingleClassifierEnhancer;
import weka.classifiers.IntervalEstimator;
import weka.classifiers.ConditionalDensityEstimator;

import weka.core.Capabilities;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Option;
import weka.core.RevisionUtils;
import weka.core.Utils;
import weka.core.Capabilities.Capability;
import weka.core.Tag;
import weka.core.SelectedTag;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;

import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Discretize;

import weka.estimators.UnivariateDensityEstimator;
import weka.estimators.UnivariateIntervalEstimator;
import weka.estimators.UnivariateQuantileEstimator;
import weka.estimators.UnivariateEqualFrequencyHistogramEstimator;
import weka.estimators.UnivariateKernelEstimator;
import weka.estimators.UnivariateNormalEstimator;

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

/**
 <!-- globalinfo-start -->
 * A regression scheme that employs any classifier on a copy of the data that has the class attribute (equal-width) discretized. The predicted value is the expected value of the mean class value for each discretized interval (based on the predicted probabilities for each interval).
 * <p/>
 <!-- globalinfo-end -->
 *
 <!-- options-start -->
 * Valid options are: <p/>
 * 
 * <pre> -B &lt;int&gt;
 *  Number of bins for equal-width discretization
 *  (default 10).
 * </pre>
 * 
 * <pre> -E
 *  Whether to delete empty bins after discretization
 *  (default false).
 * </pre>
 * 
 * <pre> -F
 *  Use equal-frequency instead of equal-width discretization.</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.J48)</pre>
 * 
 * <pre> 
 * Options specific to classifier weka.classifiers.trees.J48:
 * </pre>
 * 
 * <pre> -U
 *  Use unpruned tree.</pre>
 * 
 * <pre> -C &lt;pruning confidence&gt;
 *  Set confidence threshold for pruning.
 *  (default 0.25)</pre>
 * 
 * <pre> -M &lt;minimum number of instances&gt;
 *  Set minimum number of instances per leaf.
 *  (default 2)</pre>
 * 
 * <pre> -R
 *  Use reduced error pruning.</pre>
 * 
 * <pre> -N &lt;number of folds&gt;
 *  Set number of folds for reduced error
 *  pruning. One fold is used as pruning set.
 *  (default 3)</pre>
 * 
 * <pre> -B
 *  Use binary splits only.</pre>
 * 
 * <pre> -S
 *  Don't perform subtree raising.</pre>
 * 
 * <pre> -L
 *  Do not clean up after the tree has been built.</pre>
 * 
 * <pre> -A
 *  Laplace smoothing for predicted probabilities.</pre>
 * 
 * <pre> -Q &lt;seed&gt;
 *  Seed for random data shuffling (default 1).</pre>
 * 
 <!-- options-end -->
 *
 * @author Len Trigg (trigg@cs.waikato.ac.nz)
 * @author Eibe Frank (eibe@cs.waikato.ac.nz)
 * @version $Revision: 5925 $
 */
public class RegressionByDiscretization 
  extends SingleClassifierEnhancer implements IntervalEstimator, ConditionalDensityEstimator {
  
  /** for serialization */
  static final long serialVersionUID = 5066426153134050378L;
  
  /** The discretization filter. */
  protected Discretize m_Discretizer = new Discretize();

  /** The number of discretization intervals. */
  protected int m_NumBins = 10;

  /** The mean values for each Discretized class interval. */
  protected double [] m_ClassMeans;

  /** The class counts for each Discretized class interval. */
  protected int [] m_ClassCounts;

  /** Whether to delete empty intervals. */
  protected boolean m_DeleteEmptyBins;

  /** Header of discretized data. */
  protected Instances m_DiscretizedHeader = null;

  /** Use equal-frequency binning */
  protected boolean m_UseEqualFrequency = false;

  /** Whether to minimize absolute error, rather than squared error. */
  protected boolean m_MinimizeAbsoluteError = false;

  /** Use histogram estimator */
  public static final int ESTIMATOR_HISTOGRAM = 0;
  /** filter: Standardize training data */
  public static final int ESTIMATOR_KERNEL = 1;
  /** filter: No normalization/standardization */
  public static final int ESTIMATOR_NORMAL = 2;
  /** The filter to apply to the training data */
  public static final Tag [] TAGS_ESTIMATOR = {
    new Tag(ESTIMATOR_HISTOGRAM, "Histogram density estimator"),
    new Tag(ESTIMATOR_KERNEL, "Kernel density estimator"),
    new Tag(ESTIMATOR_NORMAL, "Normal density estimator"),
  };

  /** Which estimator to use (default: histogram) */
  protected int m_estimatorType = ESTIMATOR_HISTOGRAM;

  /** The original target values in the training data */
  protected double[] m_OriginalTargetValues = null;

  /** The converted target values in the training data */
  protected int[] m_NewTargetValues = null;

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

    return "A regression scheme that employs any "
      + "classifier on a copy of the data that has the class attribute "
      + "discretized. The predicted value is the expected value of the "
      + "mean class value for each discretized interval (based on the "
      + "predicted probabilities for each interval). This class now "
      + "also supports conditional density estimation by building "
      + "a univariate density estimator from the target values in "
      + "the training data, weighted by the class probabilities. \n\n"
      + "For more information on this process, 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, "Eibe Frank and Remco R. Bouckaert");
    result.setValue(Field.TITLE, "Conditional Density Estimation with Class Probability Estimators");
    result.setValue(Field.BOOKTITLE, "First Asian Conference on Machine Learning");
    result.setValue(Field.YEAR, "2009");
    result.setValue(Field.PAGES, "65-81");
    result.setValue(Field.PUBLISHER, "Springer Verlag");
    result.setValue(Field.ADDRESS, "Berlin");
    
    return result;
  }

  /**
   * String describing default classifier.
   * 
   * @return the default classifier classname
   */
  protected String defaultClassifierString() {
    
    return "weka.classifiers.trees.J48";
  }

  /**
   * Default constructor.
   */
  public RegressionByDiscretization() {

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

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

    // class
    result.disableAllClasses();
    result.disableAllClassDependencies();
    result.enable(Capability.NUMERIC_CLASS);
    result.enable(Capability.DATE_CLASS);
    
    result.setMinimumNumberInstances(2);
    
    return result;
  }

  /**
   * Generates the classifier.
   *
   * @param instances set of instances serving as training data 
   * @throws Exception if the classifier has not been generated successfully
   */
  public void buildClassifier(Instances instances) throws Exception {

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

    // remove instances with missing class
    instances = new Instances(instances);
    instances.deleteWithMissingClass();
    
    // Discretize the training data
    m_Discretizer.setIgnoreClass(true);
    m_Discretizer.setAttributeIndices("" + (instances.classIndex() + 1));
    m_Discretizer.setBins(getNumBins());
    m_Discretizer.setUseEqualFrequency(getUseEqualFrequency());
    m_Discretizer.setInputFormat(instances);
    Instances newTrain = Filter.useFilter(instances, m_Discretizer);

    // Should empty bins be deleted?
    if (m_DeleteEmptyBins) {

      // Figure out which classes are empty after discretization
      int numNonEmptyClasses = 0;
      boolean[] notEmptyClass = new boolean[newTrain.numClasses()];
      for (int i = 0; i < newTrain.numInstances(); i++) {
        if (!notEmptyClass[(int)newTrain.instance(i).classValue()]) {
          numNonEmptyClasses++;
          notEmptyClass[(int)newTrain.instance(i).classValue()] = true;
        }
      }
      
      // Compute new list of non-empty classes and mapping of indices
      FastVector newClassVals = new FastVector(numNonEmptyClasses);
      int[] oldIndexToNewIndex = new int[newTrain.numClasses()];
      for (int i = 0; i < newTrain.numClasses(); i++) {
        if (notEmptyClass[i]) {
         oldIndexToNewIndex[i] = newClassVals.size();
          newClassVals.addElement(newTrain.classAttribute().value(i));
        }
      }
      
      // Compute new header information
      Attribute newClass = new Attribute(newTrain.classAttribute().name(), 
                                         newClassVals);
      FastVector newAttributes = new FastVector(newTrain.numAttributes());
      for (int i = 0; i < newTrain.numAttributes(); i++) {
        if (i != newTrain.classIndex()) {
          newAttributes.addElement(newTrain.attribute(i).copy());
        } else {
          newAttributes.addElement(newClass);
        }
      }
      
      // Create new header and modify instances
      Instances newTrainTransformed = new Instances(newTrain.relationName(), 
                                                    newAttributes,
                                                    newTrain.numInstances());
      newTrainTransformed.setClassIndex(newTrain.classIndex());
      for (int i = 0; i < newTrain.numInstances(); i++) {
        Instance inst = newTrain.instance(i);
        newTrainTransformed.add(inst);
        newTrainTransformed.lastInstance().
          setClassValue(oldIndexToNewIndex[(int)inst.classValue()]);
      }
      newTrain = newTrainTransformed;
    }

    // Store target values, in case a prediction interval or computation of median is required
    m_OriginalTargetValues = new double[instances.numInstances()];
    m_NewTargetValues = new int[instances.numInstances()];
    for (int i = 0; i < m_OriginalTargetValues.length; i++) {
      m_OriginalTargetValues[i] = instances.instance(i).classValue();
      m_NewTargetValues[i] = (int)newTrain.instance(i).classValue();
    }

    m_DiscretizedHeader = new Instances(newTrain, 0);

    int numClasses = newTrain.numClasses();

    // Calculate the mean value for each bin of the new class attribute
    m_ClassMeans = new double [numClasses];
    m_ClassCounts = new int [numClasses];
    for (int i = 0; i < instances.numInstances(); i++) {
      Instance inst = newTrain.instance(i);
      if (!inst.classIsMissing()) {
        int classVal = (int) inst.classValue();
        m_ClassCounts[classVal]++;
        m_ClassMeans[classVal] += instances.instance(i).classValue();
      }
    }

    for (int i = 0; i < numClasses; i++) {
      if (m_ClassCounts[i] > 0) {
        m_ClassMeans[i] /= m_ClassCounts[i];
      }
    }

    if (m_Debug) {
      System.out.println("Bin Means");
      System.out.println("==========");
      for (int i = 0; i < m_ClassMeans.length; i++) {
        System.out.println(m_ClassMeans[i]);
      }
      System.out.println();
    }

    // Train the sub-classifier
    m_Classifier.buildClassifier(newTrain);
  }

  /**
   * Get density estimator for given instance.
   * 
   * @param inst the instance
   * @return the univariate density estimator
   * @exception Exception if the estimator can't be computed
   */
  protected UnivariateDensityEstimator getDensityEstimator(Instance instance, boolean print) throws Exception {

    // Initialize estimator
    UnivariateDensityEstimator e;
    
    if (m_estimatorType == ESTIMATOR_KERNEL) {
      e = new UnivariateKernelEstimator();
    } else if (m_estimatorType == ESTIMATOR_NORMAL) {
      e = new UnivariateNormalEstimator();
    } else {
      e = new UnivariateEqualFrequencyHistogramEstimator();

      // Set the number of bins appropriately
      ((UnivariateEqualFrequencyHistogramEstimator)e).setNumBins(getNumBins());

      // Initialize boundaries of equal frequency estimator
      for (int i = 0; i < m_OriginalTargetValues.length; i++) {
        e.addValue(m_OriginalTargetValues[i], 1.0);
      }
      
      // Construct estimator, then initialize statistics, so that only boundaries will be kept
      ((UnivariateEqualFrequencyHistogramEstimator)e).initializeStatistics();

      // Now that boundaries have been determined, we only need to update the bin weights
      ((UnivariateEqualFrequencyHistogramEstimator)e).setUpdateWeightsOnly(true);      
    }

    // Make sure structure of class attribute correct
    Instance newInstance = (Instance)instance.copy();
    newInstance.setDataset(m_DiscretizedHeader);
    double [] probs = m_Classifier.distributionForInstance(newInstance);

    // Add values to estimator
    for (int i = 0; i < m_OriginalTargetValues.length; i++) {
      e.addValue(m_OriginalTargetValues[i], probs[m_NewTargetValues[i]] * 
                 m_OriginalTargetValues.length / m_ClassCounts[m_NewTargetValues[i]]);
    }

    // Return estimator
    return e;
  }
  
  /**
   * Returns an N * 2 array, where N is the number of prediction
   * intervals. In each row, the first element contains the lower
   * boundary of the corresponding prediction interval and the second
   * element the upper boundary.
   *
   * @param inst the instance to make the prediction for.
   * @param confidenceLevel the percentage of cases that the interval should cover.
   * @return an array of prediction intervals
   * @exception Exception if the intervals can't be computed
   */
  public double[][] predictIntervals(Instance instance, double confidenceLevel) throws Exception {
    
    // Get density estimator
    UnivariateIntervalEstimator e = (UnivariateIntervalEstimator)getDensityEstimator(instance, false);

    // Return intervals
    return e.predictIntervals(confidenceLevel);
  }

  /**
   * Returns natural logarithm of density estimate for given value based on given instance.
   *
   * @param inst the instance to make the prediction for.
   * @param the value to make the prediction for.
   * @return the natural logarithm of the density estimate
   * @exception Exception if the intervals can't be computed
   */
  public double logDensity(Instance instance, double value) throws Exception {
    
    // Get density estimator
    UnivariateDensityEstimator e = getDensityEstimator(instance, true);

    // Return estimate
    return e.logDensity(value);
  }

  /**
   * Returns a predicted class for the test instance.
   *
   * @param instance the instance to be classified
   * @return predicted class value
   * @throws Exception if the prediction couldn't be made
   */
  public double classifyInstance(Instance instance) throws Exception {  

    // Make sure structure of class attribute correct
    Instance newInstance = (Instance)instance.copy();
    newInstance.setDataset(m_DiscretizedHeader);
    double [] probs = m_Classifier.distributionForInstance(newInstance);

    if (!m_MinimizeAbsoluteError) {

      // Compute actual prediction
      double prediction = 0, probSum = 0;
      for (int j = 0; j < probs.length; j++) {
        prediction += probs[j] * m_ClassMeans[j];
        probSum += probs[j];
      }
      
      return prediction /  probSum;
    } else {
    
      // Get density estimator
      UnivariateQuantileEstimator e = (UnivariateQuantileEstimator)getDensityEstimator(instance, true);
      
      // Return estimate
      return e.predictQuantile(0.5);
    }
  }

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

    Vector newVector = new Vector(5);

    newVector.addElement(new Option(
              "\tNumber of bins for equal-width discretization\n"
              + "\t(default 10).\n",
              "B", 1, "-B <int>"));

    newVector.addElement(new Option(
              "\tWhether to delete empty bins after discretization\n"
              + "\t(default false).\n",
              "E", 0, "-E"));

    newVector.addElement(new Option(
              "\tWhether to minimize absolute error, rather than squared error.\n"
              + "\t(default false).\n",
              "A", 0, "-A"));
    
    newVector.addElement(new Option(
             "\tUse equal-frequency instead of equal-width discretization.",
             "F", 0, "-F"));
    
    newVector.addElement(new Option(
             "\tWhat type of density estimator to use: 0=histogram/1=kernel/2=normal (default: 0).",
             "K", 1, "-K"));

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

    return newVector.elements();
  }

  /**
   * Parses a given list of options. <p/>
   *
   <!-- options-start -->
   <!-- options-end -->
   *
   * @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 binsString = Utils.getOption('B', options);
    if (binsString.length() != 0) {
      setNumBins(Integer.parseInt(binsString));
    } else {
      setNumBins(10);
    }

    setDeleteEmptyBins(Utils.getFlag('E', options));
    setUseEqualFrequency(Utils.getFlag('F', options));
    setMinimizeAbsoluteError(Utils.getFlag('A', options));

    String tmpStr = Utils.getOption('K', options);
    if (tmpStr.length() != 0)
      setEstimatorType(new SelectedTag(Integer.parseInt(tmpStr), TAGS_ESTIMATOR));
    else
      setEstimatorType(new SelectedTag(ESTIMATOR_HISTOGRAM, TAGS_ESTIMATOR));

    super.setOptions(options);
  }

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

    String [] superOptions = super.getOptions();
    String [] options = new String [superOptions.length + 7];
    int current = 0;

    options[current++] = "-B";
    options[current++] = "" + getNumBins();

    if (getDeleteEmptyBins()) {
      options[current++] = "-E";
    }
    
    if (getUseEqualFrequency()) {
      options[current++] = "-F";
    }

    if (getMinimizeAbsoluteError()) {
      options[current++] = "-A";
    }
    
    options[current++] = "-K";
    options[current++] = "" + m_estimatorType;

    System.arraycopy(superOptions, 0, options, current, 
                     superOptions.length);

    current += superOptions.length;
    while (current < options.length) {
      options[current++] = "";
    }

    return options;
  }

  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String numBinsTipText() {

    return "Number of bins for discretization.";
  }

  /**
   * Gets the number of bins numeric attributes will be divided into
   *
   * @return the number of bins.
   */
  public int getNumBins() {

    return m_NumBins;
  }

  /**
   * Sets the number of bins to divide each selected numeric attribute into
   *
   * @param numBins the number of bins
   */
  public void setNumBins(int numBins) {

    m_NumBins = numBins;
  }


  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String deleteEmptyBinsTipText() {

    return "Whether to delete empty bins after discretization.";
  }


  /**
   * Gets whether empty bins are deleted.
   *
   * @return true if empty bins get deleted.
   */
  public boolean getDeleteEmptyBins() {

    return m_DeleteEmptyBins;
  }

  /**
   * Sets whether to delete empty bins.
   *
   * @param b if true, empty bins will be deleted
   */
  public void setDeleteEmptyBins(boolean b) {

    m_DeleteEmptyBins = b;
  }

  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String minimizeAbsoluteErrorTipText() {

    return "Whether to minimize absolute error.";
  }


  /**
   * Gets whether to min. abs. error
   *
   * @return true if abs. err. is to be minimized
   */
  public boolean getMinimizeAbsoluteError() {

    return m_MinimizeAbsoluteError;
  }

  /**
   * Sets whether to min. abs. error.
   *
   * @param b if true, abs. err. is minimized
   */
  public void setMinimizeAbsoluteError(boolean b) {

    m_MinimizeAbsoluteError = b;
  }
  
  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String useEqualFrequencyTipText() {

    return "If set to true, equal-frequency binning will be used instead of" +
      " equal-width binning.";
  }
  
  /**
   * Get the value of UseEqualFrequency.
   *
   * @return Value of UseEqualFrequency.
   */
  public boolean getUseEqualFrequency() {
    
    return m_UseEqualFrequency;
  }
  
  /**
   * Set the value of UseEqualFrequency.
   *
   * @param newUseEqualFrequency Value to assign to UseEqualFrequency.
   */
  public void setUseEqualFrequency(boolean newUseEqualFrequency) {
    
    m_UseEqualFrequency = newUseEqualFrequency;
  }

  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String estimatorTypeTipText() {

    return "The density estimator to use.";
  }
  
  /**
   * Get the estimator type
   *
   * @return the estimator type
   */
  public  SelectedTag getEstimatorType() {
    
    return new SelectedTag(m_estimatorType, TAGS_ESTIMATOR);
  }
  
  /**
   * Set the estimator
   *
   * @param newEstimator the estimator to use
   */
  public void setEstimatorType(SelectedTag newEstimator) {
        
    if (newEstimator.getTags() == TAGS_ESTIMATOR) {
      m_estimatorType = newEstimator.getSelectedTag().getID();
    }
  }

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

    StringBuffer text = new StringBuffer();

    text.append("Regression by discretization");
    if (m_ClassMeans == null) {
      text.append(": No model built yet.");
    } else {
      text.append("\n\nClass attribute discretized into " 
                  + m_ClassMeans.length + " values\n");

      text.append("\nClassifier spec: " + getClassifierSpec() 
                  + "\n");
      text.append(m_Classifier.toString());
    }
    return text.toString();
  }
  
  /**
   * Returns the revision string.
   * 
   * @return            the revision
   */
  public String getRevision() {
    return RevisionUtils.extract("$Revision: 5925 $");
  }
 
  /**
   * Main method for testing this class.
   *
   * @param argv the options
   */
  public static void main(String [] argv) {
    runClassifier(new RegressionByDiscretization(), argv);
  }
}