• Home
• nz.ac.waikato.cms.weka
• weka-stable
• 3.8.0
• source code
• CheckSource.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.filters.CheckSource 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 .
 */

/*
 * CheckSource.java
 * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
 */

package weka.filters;

import java.io.File;
import java.util.Enumeration;
import java.util.Vector;

import weka.core.Instance;
import weka.core.Instances;
import weka.core.Option;
import weka.core.OptionHandler;
import weka.core.RevisionHandler;
import weka.core.RevisionUtils;
import weka.core.Utils;
import weka.core.converters.ConverterUtils.DataSource;

/**
 * A simple class for checking the source generated from Filters implementing
 * the weka.filters.Sourcable interface. It takes a filter, the
 * classname of the generated source and the dataset the source was generated
 * with as parameters and tests the output of the built filter against the
 * output of the generated source. Use option '-h' to display all available
 * commandline options.
 * 
 *  Valid options are:
 * 

 * 
 * 
 * -W <classname and options>
 *  The filter (incl. options) that was used to generate
 *  the source code.
 * 
 * 
 * 
 * -S <classname>
 *  The classname of the generated source code.
 * 
 * 
 * 
 * -t <file>
 *  The training set with which the source code was generated.
 * 
 * 
 * 
 * -c <index>
 *  The class index of the training set. 'first' and 'last' are
 *  valid indices.
 *  (default: none)
 * 
 * 
 * 
 * 
 * Options after -- are passed to the designated filter.
 * 

 * 
 * @author fracpete (fracpete at waikato dot ac dot nz)
 * @version $Revision: 10210 $
 * @see weka.filters.Sourcable
 */
public class CheckSource implements OptionHandler, RevisionHandler {

  /** the classifier used for generating the source code */
  protected Filter m_Filter = null;

  /** the generated source code */
  protected Filter m_SourceCode = null;

  /** the dataset to use for testing */
  protected File m_Dataset = null;

  /** the class index */
  protected int m_ClassIndex = -1;

  /**
   * 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 filter (incl. options) that was used to generate\n"
        + "\tthe source code.", "W", 1, "-W "));

    result
      .addElement(new Option("\tThe classname of the generated source code.",
        "S", 1, "-S "));

    result.addElement(new Option(
      "\tThe training set with which the source code was generated.", "t", 1,
      "-t "));

    result.addElement(new Option(
      "\tThe class index of the training set. 'first' and 'last' are\n"
        + "\tvalid indices.\n" + "\t(default: none)", "c", 1, "-c "));

    return result.elements();
  }

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

   * 
   *  Valid options are:
   * 

   * 
   * 
   * -W <classname and options>
   *  The filter (incl. options) that was used to generate
   *  the source code.
   * 
   * 
   * 
   * -S <classname>
   *  The classname of the generated source code.
   * 
   * 
   * 
   * -t <file>
   *  The training set with which the source code was generated.
   * 
   * 
   * 
   * -c <index>
   *  The class index of the training set. 'first' and 'last' are
   *  valid indices.
   *  (default: none)
   * 
   * 
   * 
   * 
   * Options after -- are passed to the designated filter.
   * 

   * 
   * @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 tmpStr;
    String[] spec;
    String classname;

    tmpStr = Utils.getOption('W', options);
    if (tmpStr.length() > 0) {
      spec = Utils.splitOptions(tmpStr);
      if (spec.length == 0) {
        throw new IllegalArgumentException(
          "Invalid filter specification string");
      }
      classname = spec[0];
      spec[0] = "";
      setFilter((Filter) Utils.forName(Filter.class, classname, spec));
    } else {
      throw new Exception("No filter (classname + options) provided!");
    }

    tmpStr = Utils.getOption('S', options);
    if (tmpStr.length() > 0) {
      spec = Utils.splitOptions(tmpStr);
      if (spec.length != 1) {
        throw new IllegalArgumentException(
          "Invalid source code specification string");
      }
      classname = spec[0];
      spec[0] = "";
      setSourceCode((Filter) Utils.forName(Filter.class, classname, spec));
    } else {
      throw new Exception("No source code (classname) provided!");
    }

    tmpStr = Utils.getOption('t', options);
    if (tmpStr.length() != 0) {
      setDataset(new File(tmpStr));
    } else {
      throw new Exception("No dataset provided!");
    }

    tmpStr = Utils.getOption('c', options);
    if (tmpStr.length() != 0) {
      if (tmpStr.equals("first")) {
        setClassIndex(0);
      } else if (tmpStr.equals("last")) {
        setClassIndex(-2);
      } else {
        setClassIndex(Integer.parseInt(tmpStr) - 1);
      }
    } else {
      setClassIndex(-1);
    }
  }

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

    result = new Vector();

    if (getFilter() != null) {
      result.add("-W");
      result.add(getFilter().getClass().getName() + " "
        + Utils.joinOptions(((OptionHandler) getFilter()).getOptions()));
    }

    if (getSourceCode() != null) {
      result.add("-S");
      result.add(getSourceCode().getClass().getName());
    }

    if (getDataset() != null) {
      result.add("-t");
      result.add(m_Dataset.getAbsolutePath());
    }

    if (getClassIndex() != -1) {
      result.add("-c");
      if (getClassIndex() == -2) {
        result.add("last");
      } else if (getClassIndex() == 0) {
        result.add("first");
      } else {
        result.add("" + (getClassIndex() + 1));
      }
    }

    return result.toArray(new String[result.size()]);
  }

  /**
   * Sets the filter to use for the comparison.
   * 
   * @param value the filter to use
   */
  public void setFilter(Filter value) {
    m_Filter = value;
  }

  /**
   * Gets the filter being used for the tests, can be null.
   * 
   * @return the currently set filter
   */
  public Filter getFilter() {
    return m_Filter;
  }

  /**
   * Sets the class to test.
   * 
   * @param value the class to test
   */
  public void setSourceCode(Filter value) {
    m_SourceCode = value;
  }

  /**
   * Gets the class to test.
   * 
   * @return the currently set class, can be null.
   */
  public Filter getSourceCode() {
    return m_SourceCode;
  }

  /**
   * Sets the dataset to use for testing.
   * 
   * @param value the dataset to use.
   */
  public void setDataset(File value) {
    if (!value.exists()) {
      throw new IllegalArgumentException("Dataset '" + value.getAbsolutePath()
        + "' does not exist!");
    } else {
      m_Dataset = value;
    }
  }

  /**
   * Gets the dataset to use for testing, can be null.
   * 
   * @return the dataset to use.
   */
  public File getDataset() {
    return m_Dataset;
  }

  /**
   * Sets the class index of the dataset.
   * 
   * @param value the class index of the dataset.
   */
  public void setClassIndex(int value) {
    m_ClassIndex = value;
  }

  /**
   * Gets the class index of the dataset.
   * 
   * @return the current class index.
   */
  public int getClassIndex() {
    return m_ClassIndex;
  }

  /**
   * compares two Instance
   * 
   * @param inst1 the first Instance object to compare
   * @param inst2 the second Instance object to compare
   * @return true if both are the same
   */
  protected boolean compare(Instance inst1, Instance inst2) {
    boolean result;
    int i;

    // check dimension
    result = (inst1.numAttributes() == inst2.numAttributes());

    // check content
    if (result) {
      for (i = 0; i < inst1.numAttributes(); i++) {
        if (Double.isNaN(inst1.value(i)) && (Double.isNaN(inst2.value(i)))) {
          continue;
        }

        if (inst1.value(i) != inst2.value(i)) {
          result = false;
          System.out.println("Values at position " + (i + 1)
            + " differ (Filter/Source code): " + inst1.value(i) + " != "
            + inst2.value(i));
          break;
        }
      }
    }

    return result;
  }

  /**
   * compares the two Instances objects
   * 
   * @param inst1 the first Instances object to compare
   * @param inst2 the second Instances object to compare
   * @return true if both are the same
   */
  protected boolean compare(Instances inst1, Instances inst2) {
    boolean result;
    int i;

    // check dimensions
    result = (inst1.numInstances() == inst2.numInstances());

    // check content
    if (result) {
      for (i = 0; i < inst1.numInstances(); i++) {
        result = compare(inst1.instance(i), inst2.instance(i));
        if (!result) {
          System.out.println("Values in line " + (i + 1) + " differ!");
          break;
        }
      }
    }

    return result;
  }

  /**
   * performs the comparison test
   * 
   * @return true if tests were successful
   * @throws Exception if tests fail
   */
  public boolean execute() throws Exception {
    boolean result;
    Instances data;
    Instance filteredInstance;
    Instances filteredInstances;
    Instance filteredInstanceSource;
    Instances filteredInstancesSource;
    DataSource source;
    Filter filter;
    Filter filterSource;
    int i;

    result = true;

    // a few checks
    if (getFilter() == null) {
      throw new Exception("No filter set!");
    }
    if (getSourceCode() == null) {
      throw new Exception("No source code set!");
    }
    if (getDataset() == null) {
      throw new Exception("No dataset set!");
    }
    if (!getDataset().exists()) {
      throw new Exception("Dataset '" + getDataset().getAbsolutePath()
        + "' does not exist!");
    }

    // load data
    source = new DataSource(getDataset().getAbsolutePath());
    data = source.getDataSet();
    if (getClassIndex() == -2) {
      data.setClassIndex(data.numAttributes() - 1);
    } else {
      data.setClassIndex(getClassIndex());
    }

    // compare output
    // 1. batch filtering
    filter = Filter.makeCopy(getFilter());
    filter.setInputFormat(data);
    filteredInstances = Filter.useFilter(data, filter);

    filterSource = Filter.makeCopy(getSourceCode());
    filterSource.setInputFormat(data);
    filteredInstancesSource = Filter.useFilter(data, filterSource);

    result = compare(filteredInstances, filteredInstancesSource);

    // 2. instance by instance
    if (result) {
      filter = Filter.makeCopy(getFilter());
      filter.setInputFormat(data);
      Filter.useFilter(data, filter);

      filterSource = Filter.makeCopy(getSourceCode());
      filterSource.setInputFormat(data);

      for (i = 0; i < data.numInstances(); i++) {
        filter.input(data.instance(i));
        filter.batchFinished();
        filteredInstance = filter.output();

        filterSource.input(data.instance(i));
        filterSource.batchFinished();
        filteredInstanceSource = filterSource.output();

        if (!compare(filteredInstance, filteredInstanceSource)) {
          System.out.println((i + 1) + ". instance (Filter/Source code): "
            + filteredInstance + " != " + filteredInstanceSource);
        }
      }
    }

    return result;
  }

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

  /**
   * Executes the tests, use "-h" to list the commandline options.
   * 
   * @param args the commandline parameters
   * @throws Exception if something goes wrong
   */
  public static void main(String[] args) throws Exception {
    CheckSource check;
    StringBuffer text;
    Enumeration enm;

    check = new CheckSource();
    if (Utils.getFlag('h', args)) {
      text = new StringBuffer();
      text.append("\nHelp requested:\n\n");
      enm = check.listOptions();
      while (enm.hasMoreElements()) {
        Option option = enm.nextElement();
        text.append(option.synopsis() + "\n");
        text.append(option.description() + "\n");
      }
      System.out.println("\n" + text + "\n");
    } else {
      check.setOptions(args);
      if (check.execute()) {
        System.out.println("Tests OK!");
      } else {
        System.out.println("Tests failed!");
      }
    }
  }
}