• Home
• nz.ac.waikato.cms.weka
• weka-dev
• 3.9.5
• source code
• SerializedClassifier.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.misc.SerializedClassifier 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 .
 */

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

package weka.classifiers.misc;

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

import weka.classifiers.AbstractClassifier;
import weka.classifiers.Classifier;
import weka.core.Capabilities;
import weka.core.Capabilities.Capability;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Option;
import weka.core.RevisionUtils;
import weka.core.SerializationHelper;
import weka.core.Utils;

/**
 *  A wrapper around a serialized classifier model.
 * This classifier loads a serialized models and uses it to make predictions.

 * 

 * Warning: since the serialized model doesn't get changed, cross-validation
 * cannot bet used with this classifier.
 * 

 * 
 * 
 *  Valid options are:
 * 

 * 
 * 
 * -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console
 * 
 * 
 * 
 * -model <filename>
 *  The file containing the serialized model.
 *  (required)
 * 
 * 
 * 
 * 
 * @author fracpete (fracpete at waikato dot ac dot nz)
 * @version $Revision: 15519 $
 */
public class SerializedClassifier extends AbstractClassifier {

  /** for serialization */
  private static final long serialVersionUID = 4599593909947628642L;

  /** the serialized classifier model used for making predictions */
  protected transient Classifier m_Model = null;

  /** the file where the serialized model is stored */
  protected File m_ModelFile = new File(System.getProperty("user.dir"));

  /**
   * Returns a string describing classifier
   * 
   * @return a description suitable for displaying in the explorer/experimenter
   *         gui
   */
  public String globalInfo() {
    return "A wrapper around a serialized classifier model. This classifier loads "
      + "a serialized models and uses it to make predictions.\n\n"
      + "Warning: since the serialized model doesn't get changed, cross-validation "
      + "cannot bet used with this classifier.";
  }

  /**
   * Gets 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 file containing the serialized model.\n" + "\t(required)",
      "model", 1, "-model "));

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

    return result.elements();
  }

  /**
   * returns the options of the current setup
   * 
   * @return the current options
   */
  @Override
  public String[] getOptions() {

    Vector result = new Vector();

    result.add("-model");
    result.add("" + getModelFile());

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

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

  /**
   * Parses the options for this object.
   * 

   * 
   *  Valid options are:
   * 

   * 
   * 
   * -D
   *  If set, classifier is run in debug mode and
   *  may output additional info to the console
   * 
   * 
   * 
   * -model <filename>
   *  The file containing the serialized model.
   *  (required)
   * 
   * 
   * 
   * 
   * @param options the options to use
   * @throws Exception if setting of options fails
   */
  @Override
  public void setOptions(String[] options) throws Exception {
    String tmpStr;

    tmpStr = Utils.getOption("model", options);
    if (tmpStr.length() != 0) {
      setModelFile(new File(tmpStr));
    } else {
      setModelFile(new File(System.getProperty("user.dir")));
    }

    super.setOptions(options);
  }

  /**
   * Returns the tip text for this property
   * 
   * @return tip text for this property suitable for displaying in the
   *         explorer/experimenter gui
   */
  public String modelFileTipText() {
    return "The serialized classifier model to use for predictions.";
  }

  /**
   * Gets the file containing the serialized model.
   * 
   * @return the file.
   */
  public File getModelFile() {
    return m_ModelFile;
  }

  /**
   * Sets the file containing the serialized model.
   * 
   * @param value the file.
   */
  public void setModelFile(File value) {
    m_ModelFile = value;

    if (value.exists() && value.isFile()) {
      try {
        initModel();
      } catch (Exception e) {
        throw new IllegalArgumentException("Cannot load model from file '"
          + value + "': " + e);
      }
    }
  }

  /**
   * Sets the fully built model to use, if one doesn't want to load a model from
   * a file or already deserialized a model from somewhere else.
   * 
   * @param value the built model
   * @see #getCurrentModel()
   */
  public void setModel(Classifier value) {
    m_Model = value;
  }

  /**
   * Gets the currently loaded model (can be null). Call buildClassifier method
   * to load model from file.
   * 
   * @return the current model
   * @see #setModel(Classifier)
   */
  public Classifier getCurrentModel() {
    return m_Model;
  }

  /**
   * loads the serialized model if necessary, throws an Exception if the
   * derserialization fails.
   * 
   * @throws Exception if deserialization fails
   */
  protected void initModel() throws Exception {
    if (m_Model == null) {
      m_Model = (Classifier) SerializationHelper.read(m_ModelFile
        .getAbsolutePath());
    }
  }

  /**
   * Returns default capabilities of the base classifier.
   * 
   * @return the capabilities of the base classifier
   */
  @Override
  public Capabilities getCapabilities() {
    Capabilities result;

    // init model if necessary
    if (m_ModelFile != null && m_ModelFile.exists() && m_ModelFile.isFile()) {
      try {
        initModel();
      } catch (Exception e) {
        System.err.println(e);
      }
    }

    if (m_Model != null) {
      result = m_Model.getCapabilities();
    } else {
      result = new Capabilities(this);
      result.disableAll();
    }

    // set dependencies
    for (Capability cap : Capability.values()) {
      result.enableDependency(cap);
    }

    result.setOwner(this);

    return result;
  }

  /**
   * Calculates the class membership probabilities for the given test instance.
   * 
   * @param instance the instance to be classified
   * @return preedicted class probability distribution
   * @throws Exception if distribution can't be computed successfully
   */
  @Override
  public double[] distributionForInstance(Instance instance) throws Exception {
    double[] result;

    // init model if necessary
    initModel();

    result = m_Model.distributionForInstance(instance);

    return result;
  }

  /**
   * loads only the serialized classifier
   * 
   * @param data the training instances
   * @throws Exception if something goes wrong
   */
  @Override
  public void buildClassifier(Instances data) throws Exception {
    // init model if necessary
    initModel();

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

  /**
   * Returns a string representation of the classifier
   * 
   * @return the string representation of the classifier
   */
  @Override
  public String toString() {
    StringBuffer result;

    if (m_Model == null) {
      result = new StringBuffer("No model loaded yet.");
    } else {
      result = new StringBuffer();
      result.append("SerializedClassifier\n");
      result.append("====================\n\n");
      result.append("File: " + getModelFile() + "\n\n");
      result.append(m_Model.toString());
    }

    return result.toString();
  }

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

  /**
   * Runs the classifier with the given options
   * 
   * @param args the commandline options
   */
  public static void main(String[] args) {
    runClassifier(new SerializedClassifier(), args);
  }
}