• Home
• nz.ac.waikato.cms.weka
• multiInstanceLearning
• 1.0.9
• source code
• MIWrapper.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

weka.classifiers.mi.MIWrapper Maven / Gradle / Ivy

/*
 *   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 3 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, see .
 */

/*
 * MIWrapper.java
 * Copyright (C) 2005 University of Waikato, Hamilton, New Zealand
 * 
 */

package weka.classifiers.mi;

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

import weka.classifiers.SingleClassifierEnhancer;
import weka.core.Capabilities;
import weka.core.Capabilities.Capability;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.MultiInstanceCapabilitiesHandler;
import weka.core.Option;
import weka.core.OptionHandler;
import weka.core.RevisionUtils;
import weka.core.SelectedTag;
import weka.core.Tag;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;
import weka.core.TechnicalInformationHandler;
import weka.core.Utils;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.MultiInstanceToPropositional;

/**
 *  A simple Wrapper method for applying standard
 * propositional learners to multi-instance data.

 * 

 * For more information see:

 * 

 * E. T. Frank, X. Xu (2003). Applying propositional learning algorithms to
 * multi-instance data. Department of Computer Science, University of Waikato,
 * Hamilton, NZ.
 * 

 * 
 * 
 *  BibTeX:
 * 
 * 
 * @techreport{Frank2003,
 *    address = {Department of Computer Science, University of Waikato, Hamilton, NZ},
 *    author = {E. T. Frank and X. Xu},
 *    institution = {University of Waikato},
 *    month = {06},
 *    title = {Applying propositional learning algorithms to multi-instance data},
 *    year = {2003}
 * }
 * 
 * 

 * 
 * 
 *  Valid options are:
 * 

 * 
 * 
 * -P [1|2|3]
 *  The method used in testing:
 *  1.arithmetic average
 *  2.geometric average
 *  3.max probability of positive bag.
 *  (default: 1)
 * 
 * 
 * 
 * -A [0|1|2|3]
 *  The type of weight setting for each single-instance:
 *  0.keep the weight to be the same as the original value;
 *  1.weight = 1.0
 *  2.weight = 1.0/Total number of single-instance in the
 *   corresponding bag
 *  3. weight = Total number of single-instance / (Total
 *   number of bags * Total number of single-instance 
 *   in the corresponding bag).
 *  (default: 3)
 * 
 * 
 * 
 * -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.rules.ZeroR)
 * 
 * 
 * 
 * Options specific to classifier weka.classifiers.rules.ZeroR:
 * 
 * 
 * 
 * -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console
 * 
 * 
 * 
 * 
 * @author Eibe Frank ([email protected])
 * @author Xin Xu ([email protected])
 * @version $Revision: 10369 $
 */
public class MIWrapper extends SingleClassifierEnhancer implements
  MultiInstanceCapabilitiesHandler, OptionHandler, TechnicalInformationHandler {

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

  /** The number of the class labels */
  protected int m_NumClasses;

  /** arithmetic average */
  public static final int TESTMETHOD_ARITHMETIC = 1;
  /** geometric average */
  public static final int TESTMETHOD_GEOMETRIC = 2;
  /** max probability of positive bag */
  public static final int TESTMETHOD_MAXPROB = 3;
  /** the test methods */
  public static final Tag[] TAGS_TESTMETHOD = {
    new Tag(TESTMETHOD_ARITHMETIC, "arithmetic average"),
    new Tag(TESTMETHOD_GEOMETRIC, "geometric average"),
    new Tag(TESTMETHOD_MAXPROB, "max probability of positive bag") };

  /** the test method */
  protected int m_Method = TESTMETHOD_GEOMETRIC;

  /** Filter used to convert MI dataset into single-instance dataset */
  protected MultiInstanceToPropositional m_ConvertToProp = new MultiInstanceToPropositional();

  /** the single-instance weight setting method */
  protected int m_WeightMethod = MultiInstanceToPropositional.WEIGHTMETHOD_INVERSE2;

  /**
   * Returns a string describing this filter
   * 
   * @return a description of the filter suitable for displaying in the
   *         explorer/experimenter gui
   */
  public String globalInfo() {
    return "A simple Wrapper method for applying standard propositional learners "
      + "to multi-instance data.\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
   */
  @Override
  public TechnicalInformation getTechnicalInformation() {
    TechnicalInformation result;

    result = new TechnicalInformation(Type.TECHREPORT);
    result.setValue(Field.AUTHOR, "E. T. Frank and X. Xu");
    result.setValue(Field.TITLE,
      "Applying propositional learning algorithms to multi-instance data");
    result.setValue(Field.YEAR, "2003");
    result.setValue(Field.MONTH, "06");
    result.setValue(Field.INSTITUTION, "University of Waikato");
    result.setValue(Field.ADDRESS,
      "Department of Computer Science, University of Waikato, Hamilton, NZ");

    return result;
  }

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

    Vector result = new Vector();

    result.addElement(new Option("\tThe method used in testing:\n"
      + "\t1.arithmetic average\n" + "\t2.geometric average\n"
      + "\t3.max probability of positive bag.\n" + "\t(default: 1)", "P", 1,
      "-P [1|2|3]"));

    result.addElement(new Option(
      "\tThe type of weight setting for each single-instance:\n"
        + "\t0.keep the weight to be the same as the original value;\n"
        + "\t1.weight = 1.0\n"
        + "\t2.weight = 1.0/Total number of single-instance in the\n"
        + "\t\tcorresponding bag\n"
        + "\t3. weight = Total number of single-instance / (Total\n"
        + "\t\tnumber of bags * Total number of single-instance \n"
        + "\t\tin the corresponding bag).\n" + "\t(default: 3)", "A", 1,
      "-A [0|1|2|3]"));

    result.addAll(Collections.list(super.listOptions()));

    return result.elements();
  }

  /**
   * Parses a given list of options.
   * 

   * 
   *  Valid options are:
   * 

   * 
   * 
   * -P [1|2|3]
   *  The method used in testing:
   *  1.arithmetic average
   *  2.geometric average
   *  3.max probability of positive bag.
   *  (default: 1)
   * 
   * 
   * 
   * -A [0|1|2|3]
   *  The type of weight setting for each single-instance:
   *  0.keep the weight to be the same as the original value;
   *  1.weight = 1.0
   *  2.weight = 1.0/Total number of single-instance in the
   *   corresponding bag
   *  3. weight = Total number of single-instance / (Total
   *   number of bags * Total number of single-instance 
   *   in the corresponding bag).
   *  (default: 3)
   * 
   * 
   * 
   * -W
   *  Full name of base classifier.
   *  (default: weka.classifiers.rules.ZeroR)
   * 
   * 
   * 
   * Options specific to classifier weka.classifiers.rules.ZeroR:
   * 
   * 
   * 
   * 
   * @param options the list of options as an array of strings
   * @throws Exception if an option is not supported
   */
  @Override
  public void setOptions(String[] options) throws Exception {

    String methodString = Utils.getOption('P', options);
    if (methodString.length() != 0) {
      setMethod(new SelectedTag(Integer.parseInt(methodString), TAGS_TESTMETHOD));
    } else {
      setMethod(new SelectedTag(TESTMETHOD_ARITHMETIC, TAGS_TESTMETHOD));
    }

    String weightString = Utils.getOption('A', options);
    if (weightString.length() != 0) {
      setWeightMethod(new SelectedTag(Integer.parseInt(weightString),
        MultiInstanceToPropositional.TAGS_WEIGHTMETHOD));
    } else {
      setWeightMethod(new SelectedTag(
        MultiInstanceToPropositional.WEIGHTMETHOD_INVERSE2,
        MultiInstanceToPropositional.TAGS_WEIGHTMETHOD));
    }

    super.setOptions(options);

    Utils.checkForRemainingOptions(options);
  }

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

    Vector result = new Vector();

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

    result.add("-A");
    result.add("" + m_WeightMethod);

    Collections.addAll(result, super.getOptions());

    return 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 weightMethodTipText() {
    return "The method used for weighting the instances.";
  }

  /**
   * The new method for weighting the instances.
   * 
   * @param method the new method
   */
  public void setWeightMethod(SelectedTag method) {
    if (method.getTags() == MultiInstanceToPropositional.TAGS_WEIGHTMETHOD) {
      m_WeightMethod = method.getSelectedTag().getID();
    }
  }

  /**
   * Returns the current weighting method for instances.
   * 
   * @return the current weighting method
   */
  public SelectedTag getWeightMethod() {
    return new SelectedTag(m_WeightMethod,
      MultiInstanceToPropositional.TAGS_WEIGHTMETHOD);
  }

  /**
   * Returns the tip text for this property
   * 
   * @return tip text for this property suitable for displaying in the
   *         explorer/experimenter gui
   */
  public String methodTipText() {
    return "The method used for testing.";
  }

  /**
   * Set the method used in testing.
   * 
   * @param method the index of method to use.
   */
  public void setMethod(SelectedTag method) {
    if (method.getTags() == TAGS_TESTMETHOD) {
      m_Method = method.getSelectedTag().getID();
    }
  }

  /**
   * Get the method used in testing.
   * 
   * @return the index of method used in testing.
   */
  public SelectedTag getMethod() {
    return new SelectedTag(m_Method, TAGS_TESTMETHOD);
  }

  /**
   * Returns default capabilities of the classifier.
   * 
   * @return the capabilities of this classifier
   */
  @Override
  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);
    }
    result.enable(Capability.RELATIONAL_ATTRIBUTES);
    result.enable(Capability.MISSING_CLASS_VALUES);
    result.disable(Capability.MISSING_VALUES);

    // other
    result.enable(Capability.ONLY_MULTIINSTANCE);

    return result;
  }

  /**
   * Returns the capabilities of this multi-instance classifier for the
   * relational data.
   * 
   * @return the capabilities of this object
   * @see Capabilities
   */
  @Override
  public Capabilities getMultiInstanceCapabilities() {
    Capabilities result = super.getCapabilities();

    // class
    result.disableAllClasses();
    result.enable(Capability.NO_CLASS);

    return result;
  }

  /**
   * Builds the classifier
   * 
   * @param data the training data to be used for generating the boosted
   *          classifier.
   * @throws Exception if the classifier could not be built successfully
   */
  @Override
  public void buildClassifier(Instances data) throws Exception {

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

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

    if (m_Classifier == null) {
      throw new Exception("A base classifier has not been specified!");
    }

    if (getDebug()) {
      System.out.println("Start training ...");
    }
    m_NumClasses = train.numClasses();

    // convert the training dataset into single-instance dataset
    m_ConvertToProp.setWeightMethod(getWeightMethod());
    m_ConvertToProp.setInputFormat(train);
    train = Filter.useFilter(train, m_ConvertToProp);
    train.deleteAttributeAt(0); // remove the bag index attribute

    m_Classifier.buildClassifier(train);
  }

  /**
   * Computes the distribution for a given exemplar
   * 
   * @param exmp the exemplar for which distribution is computed
   * @return the distribution
   * @throws Exception if the distribution can't be computed successfully
   */
  @Override
  public double[] distributionForInstance(Instance exmp) throws Exception {

    Instances testData = new Instances(exmp.dataset(), 0);
    testData.add(exmp);

    // convert the training dataset into single-instance dataset
    m_ConvertToProp.setWeightMethod(new SelectedTag(
      MultiInstanceToPropositional.WEIGHTMETHOD_ORIGINAL,
      MultiInstanceToPropositional.TAGS_WEIGHTMETHOD));
    testData = Filter.useFilter(testData, m_ConvertToProp);
    testData.deleteAttributeAt(0); // remove the bag index attribute

    // Compute the log-probability of the bag
    double[] distribution = new double[m_NumClasses];
    double nI = testData.numInstances();
    double[] maxPr = new double[m_NumClasses];

    for (int i = 0; i < nI; i++) {
      double[] dist = m_Classifier
        .distributionForInstance(testData.instance(i));
      for (int j = 0; j < m_NumClasses; j++) {

        switch (m_Method) {
        case TESTMETHOD_ARITHMETIC:
          distribution[j] += dist[j] / nI;
          break;
        case TESTMETHOD_GEOMETRIC:
          // Avoid 0/1 probability
          if (dist[j] < 0.001) {
            dist[j] = 0.001;
          } else if (dist[j] > 0.999) {
            dist[j] = 0.999;
          }

          distribution[j] += Math.log(dist[j]) / nI;
          break;
        case TESTMETHOD_MAXPROB:
          if (dist[j] > maxPr[j]) {
            maxPr[j] = dist[j];
          }
          break;
        }
      }
    }

    if (m_Method == TESTMETHOD_GEOMETRIC) {
      for (int j = 0; j < m_NumClasses; j++) {
        distribution[j] = Math.exp(distribution[j]);
      }
    }

    if (m_Method == TESTMETHOD_MAXPROB) { // for positive bag
      distribution[1] = maxPr[1];
      distribution[0] = 1 - distribution[1];
    }

    if (Utils.eq(Utils.sum(distribution), 0)) {
      for (int i = 0; i < distribution.length; i++) {
        distribution[i] = 1.0 / distribution.length;
      }
    } else {
      Utils.normalize(distribution);
    }

    return distribution;
  }

  /**
   * Gets a string describing the classifier.
   * 
   * @return a string describing the classifer built.
   */
  @Override
  public String toString() {
    return "MIWrapper with base classifier: \n" + m_Classifier.toString();
  }

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

  /**
   * Main method for testing this class.
   * 
   * @param argv should contain the command line arguments to the scheme (see
   *          Evaluation)
   */
  public static void main(String[] argv) {
    runClassifier(new MIWrapper(), argv);
  }
}