Java tutorial
/* * 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 <http://www.gnu.org/licenses/>. */ /* * VotedPerceptron.java * Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand * */ package weka.classifiers.functions; import java.util.Collections; import java.util.Enumeration; import java.util.Random; import java.util.Vector; import weka.classifiers.AbstractClassifier; import weka.core.Capabilities; import weka.core.Capabilities.Capability; import weka.core.Instance; import weka.core.Instances; import weka.core.Option; import weka.core.OptionHandler; import weka.core.RevisionUtils; 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.NominalToBinary; import weka.filters.unsupervised.attribute.ReplaceMissingValues; /** <!-- globalinfo-start --> * Implementation of the voted perceptron algorithm by Freund and Schapire. Globally replaces all missing values, and transforms nominal attributes into binary ones.<br/> * <br/> * For more information, see:<br/> * <br/> * Y. Freund, R. E. Schapire: Large margin classification using the perceptron algorithm. In: 11th Annual Conference on Computational Learning Theory, New York, NY, 209-217, 1998. * <p/> <!-- globalinfo-end --> * <!-- technical-bibtex-start --> * BibTeX: * <pre> * @inproceedings{Freund1998, * address = {New York, NY}, * author = {Y. Freund and R. E. Schapire}, * booktitle = {11th Annual Conference on Computational Learning Theory}, * pages = {209-217}, * publisher = {ACM Press}, * title = {Large margin classification using the perceptron algorithm}, * year = {1998} * } * </pre> * <p/> <!-- technical-bibtex-end --> * <!-- options-start --> * Valid options are: <p/> * * <pre> -I <int> * The number of iterations to be performed. * (default 1)</pre> * * <pre> -E <double> * The exponent for the polynomial kernel. * (default 1)</pre> * * <pre> -S <int> * The seed for the random number generation. * (default 1)</pre> * * <pre> -M <int> * The maximum number of alterations allowed. * (default 10000)</pre> * <!-- options-end --> * * @author Eibe Frank (eibe@cs.waikato.ac.nz) * @version $Revision$ */ public class VotedPerceptron extends AbstractClassifier implements OptionHandler, TechnicalInformationHandler { /** for serialization */ static final long serialVersionUID = -1072429260104568698L; /** The maximum number of alterations to the perceptron */ private int m_MaxK = 10000; /** The number of iterations */ private int m_NumIterations = 1; /** The exponent */ private double m_Exponent = 1.0; /** The actual number of alterations */ private int m_K = 0; /** The training instances added to the perceptron */ private int[] m_Additions = null; /** Addition or subtraction? */ private boolean[] m_IsAddition = null; /** The weights for each perceptron */ private int[] m_Weights = null; /** The training instances */ private Instances m_Train = null; /** Seed used for shuffling the dataset */ private int m_Seed = 1; /** The filter used to make attributes numeric. */ private NominalToBinary m_NominalToBinary; /** The filter used to get rid of missing values. */ private ReplaceMissingValues m_ReplaceMissingValues; /** * Returns a string describing this classifier * @return a description of the classifier suitable for * displaying in the explorer/experimenter gui */ public String globalInfo() { return "Implementation of the voted perceptron algorithm by Freund and " + "Schapire. Globally replaces all missing values, and transforms " + "nominal attributes into binary ones.\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 */ public TechnicalInformation getTechnicalInformation() { TechnicalInformation result; result = new TechnicalInformation(Type.INPROCEEDINGS); result.setValue(Field.AUTHOR, "Y. Freund and R. E. Schapire"); result.setValue(Field.TITLE, "Large margin classification using the perceptron algorithm"); result.setValue(Field.BOOKTITLE, "11th Annual Conference on Computational Learning Theory"); result.setValue(Field.YEAR, "1998"); result.setValue(Field.PAGES, "209-217"); result.setValue(Field.PUBLISHER, "ACM Press"); result.setValue(Field.ADDRESS, "New York, NY"); return result; } /** * Returns an enumeration describing the available options. * * @return an enumeration of all the available options. */ public Enumeration<Option> listOptions() { Vector<Option> newVector = new Vector<Option>(4); newVector.addElement( new Option("\tThe number of iterations to be performed.\n" + "\t(default 1)", "I", 1, "-I <int>")); newVector.addElement( new Option("\tThe exponent for the polynomial kernel.\n" + "\t(default 1)", "E", 1, "-E <double>")); newVector.addElement( new Option("\tThe seed for the random number generation.\n" + "\t(default 1)", "S", 1, "-S <int>")); newVector.addElement(new Option("\tThe maximum number of alterations allowed.\n" + "\t(default 10000)", "M", 1, "-M <int>")); newVector.addAll(Collections.list(super.listOptions())); return newVector.elements(); } /** * Parses a given list of options. <p/> * <!-- options-start --> * Valid options are: <p/> * * <pre> -I <int> * The number of iterations to be performed. * (default 1)</pre> * * <pre> -E <double> * The exponent for the polynomial kernel. * (default 1)</pre> * * <pre> -S <int> * The seed for the random number generation. * (default 1)</pre> * * <pre> -M <int> * The maximum number of alterations allowed. * (default 10000)</pre> * <!-- 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 iterationsString = Utils.getOption('I', options); if (iterationsString.length() != 0) { m_NumIterations = Integer.parseInt(iterationsString); } else { m_NumIterations = 1; } String exponentsString = Utils.getOption('E', options); if (exponentsString.length() != 0) { m_Exponent = (new Double(exponentsString)).doubleValue(); } else { m_Exponent = 1.0; } String seedString = Utils.getOption('S', options); if (seedString.length() != 0) { m_Seed = Integer.parseInt(seedString); } else { m_Seed = 1; } String alterationsString = Utils.getOption('M', options); if (alterationsString.length() != 0) { m_MaxK = Integer.parseInt(alterationsString); } else { m_MaxK = 10000; } super.setOptions(options); Utils.checkForRemainingOptions(options); } /** * Gets the current settings of the classifier. * * @return an array of strings suitable for passing to setOptions */ public String[] getOptions() { Vector<String> options = new Vector<String>(); options.add("-I"); options.add("" + m_NumIterations); options.add("-E"); options.add("" + m_Exponent); options.add("-S"); options.add("" + m_Seed); options.add("-M"); options.add("" + m_MaxK); Collections.addAll(options, super.getOptions()); return options.toArray(new String[0]); } /** * Returns default capabilities of the classifier. * * @return the capabilities of this classifier */ public Capabilities getCapabilities() { Capabilities result = super.getCapabilities(); result.disableAll(); // attributes result.enable(Capability.NOMINAL_ATTRIBUTES); result.enable(Capability.NUMERIC_ATTRIBUTES); result.enable(Capability.DATE_ATTRIBUTES); result.enable(Capability.MISSING_VALUES); // class result.enable(Capability.BINARY_CLASS); result.enable(Capability.MISSING_CLASS_VALUES); // instances result.setMinimumNumberInstances(0); return result; } /** * Builds the ensemble of perceptrons. * * @param insts the data to train the classifier with * @throws Exception if something goes wrong during building */ public void buildClassifier(Instances insts) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(insts); // remove instances with missing class insts = new Instances(insts); insts.deleteWithMissingClass(); // Filter data m_Train = new Instances(insts); m_ReplaceMissingValues = new ReplaceMissingValues(); m_ReplaceMissingValues.setInputFormat(m_Train); m_Train = Filter.useFilter(m_Train, m_ReplaceMissingValues); m_NominalToBinary = new NominalToBinary(); m_NominalToBinary.setInputFormat(m_Train); m_Train = Filter.useFilter(m_Train, m_NominalToBinary); /** Randomize training data */ m_Train.randomize(new Random(m_Seed)); /** Make space to store perceptrons */ m_Additions = new int[m_MaxK + 1]; m_IsAddition = new boolean[m_MaxK + 1]; m_Weights = new int[m_MaxK + 1]; /** Compute perceptrons */ m_K = 0; out: for (int it = 0; it < m_NumIterations; it++) { for (int i = 0; i < m_Train.numInstances(); i++) { Instance inst = m_Train.instance(i); if (!inst.classIsMissing()) { int prediction = makePrediction(m_K, inst); int classValue = (int) inst.classValue(); if (prediction == classValue) { m_Weights[m_K]++; } else { m_IsAddition[m_K] = (classValue == 1); m_Additions[m_K] = i; m_K++; m_Weights[m_K]++; } if (m_K == m_MaxK) { break out; } } } } } /** * Outputs the distribution for the given output. * * Pipes output of SVM through sigmoid function. * @param inst the instance for which distribution is to be computed * @return the distribution * @throws Exception if something goes wrong */ public double[] distributionForInstance(Instance inst) throws Exception { // Filter instance m_ReplaceMissingValues.input(inst); m_ReplaceMissingValues.batchFinished(); inst = m_ReplaceMissingValues.output(); m_NominalToBinary.input(inst); m_NominalToBinary.batchFinished(); inst = m_NominalToBinary.output(); // Get probabilities double output = 0, sumSoFar = 0; if (m_K > 0) { for (int i = 0; i <= m_K; i++) { if (sumSoFar < 0) { output -= m_Weights[i]; } else { output += m_Weights[i]; } if (m_IsAddition[i]) { sumSoFar += innerProduct(m_Train.instance(m_Additions[i]), inst); } else { sumSoFar -= innerProduct(m_Train.instance(m_Additions[i]), inst); } } } double[] result = new double[2]; result[1] = 1 / (1 + Math.exp(-output)); result[0] = 1 - result[1]; return result; } /** * Returns textual description of classifier. * * @return the model as string */ public String toString() { return "VotedPerceptron: Number of perceptrons=" + m_K; } /** * Returns the tip text for this property * @return tip text for this property suitable for * displaying in the explorer/experimenter gui */ public String maxKTipText() { return "The maximum number of alterations to the perceptron."; } /** * Get the value of maxK. * * @return Value of maxK. */ public int getMaxK() { return m_MaxK; } /** * Set the value of maxK. * * @param v Value to assign to maxK. */ public void setMaxK(int v) { m_MaxK = v; } /** * Returns the tip text for this property * @return tip text for this property suitable for * displaying in the explorer/experimenter gui */ public String numIterationsTipText() { return "Number of iterations to be performed."; } /** * Get the value of NumIterations. * * @return Value of NumIterations. */ public int getNumIterations() { return m_NumIterations; } /** * Set the value of NumIterations. * * @param v Value to assign to NumIterations. */ public void setNumIterations(int v) { m_NumIterations = v; } /** * Returns the tip text for this property * @return tip text for this property suitable for * displaying in the explorer/experimenter gui */ public String exponentTipText() { return "Exponent for the polynomial kernel."; } /** * Get the value of exponent. * * @return Value of exponent. */ public double getExponent() { return m_Exponent; } /** * Set the value of exponent. * * @param v Value to assign to exponent. */ public void setExponent(double v) { m_Exponent = v; } /** * Returns the tip text for this property * @return tip text for this property suitable for * displaying in the explorer/experimenter gui */ public String seedTipText() { return "Seed for the random number generator."; } /** * Get the value of Seed. * * @return Value of Seed. */ public int getSeed() { return m_Seed; } /** * Set the value of Seed. * * @param v Value to assign to Seed. */ public void setSeed(int v) { m_Seed = v; } /** * Computes the inner product of two instances * * @param i1 first instance * @param i2 second instance * @return the inner product * @throws Exception if computation fails */ private double innerProduct(Instance i1, Instance i2) throws Exception { // we can do a fast dot product double result = 0; int n1 = i1.numValues(); int n2 = i2.numValues(); int classIndex = m_Train.classIndex(); for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) { int ind1 = i1.index(p1); int ind2 = i2.index(p2); if (ind1 == ind2) { if (ind1 != classIndex) { result += i1.valueSparse(p1) * i2.valueSparse(p2); } p1++; p2++; } else if (ind1 > ind2) { p2++; } else { p1++; } } result += 1.0; if (m_Exponent != 1) { return Math.pow(result, m_Exponent); } else { return result; } } /** * Compute a prediction from a perceptron * * @param k * @param inst the instance to make a prediction for * @return the prediction * @throws Exception if computation fails */ private int makePrediction(int k, Instance inst) throws Exception { double result = 0; for (int i = 0; i < k; i++) { if (m_IsAddition[i]) { result += innerProduct(m_Train.instance(m_Additions[i]), inst); } else { result -= innerProduct(m_Train.instance(m_Additions[i]), inst); } } if (result < 0) { return 0; } else { return 1; } } /** * Returns the revision string. * * @return the revision */ public String getRevision() { return RevisionUtils.extract("$Revision$"); } /** * Main method. * * @param argv the commandline options */ public static void main(String[] argv) { runClassifier(new VotedPerceptron(), argv); } }