valuereplenishment.java

一个很好的LIBSVM的JAVA源码。对于要研究和改进SVM算法的学者。可以参考。来自数据挖掘工具YALE工具包。

/*
 *  YALE - Yet Another Learning Environment
 *  Copyright (C) 2001-2004
 *      Simon Fischer, Ralf Klinkenberg, Ingo Mierswa, 
 *          Katharina Morik, Oliver Ritthoff
 *      Artificial Intelligence Unit
 *      Computer Science Department
 *      University of Dortmund
 *      44221 Dortmund,  Germany
 *  email: [e-mail]
 *  web:   http://yale.cs.uni-dortmund.de/
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 *  USA.
 */
package edu.udo.cs.yale.operator.preprocessing;

import edu.udo.cs.yale.operator.Operator;
import edu.udo.cs.yale.operator.IOObject;
import edu.udo.cs.yale.operator.OperatorException;
import edu.udo.cs.yale.operator.parameter.*;
import edu.udo.cs.yale.example.ExampleSet;
import edu.udo.cs.yale.example.ExampleReader;
import edu.udo.cs.yale.example.Example;
import edu.udo.cs.yale.example.Attribute;
import edu.udo.cs.yale.tools.LogService;

import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;

/** Abstract superclass for all operators that replenish values, e.g. nan or infinite values.
 *
 *  @version $Id: ValueReplenishment.java,v 1.3 2004/09/09 12:00:53 ingomierswa Exp $
 */
public abstract class ValueReplenishment extends Operator {

    /** Returns true iff the value should be replenished. */
    public abstract boolean replenishValue(double currentValue);

    /** Returns the value of the replenishment function with the given index. */
    public abstract double getReplenishmentValue(int functionIndex, Attribute attribute, double currentValue);

    /** Returns an array of all replenishment functions. */
    public abstract String[] getFunctionNames();

    /** Returns the index of the replenishment function which will be used for attributes not
     *  listed in the parameter list "columns". */
    public abstract int getDefaultFunction();

    /** Returns the index of the replenishment function which will be used for attributes
     *  listed in the parameter list "columns". */
    public abstract int getDefaultColumnFunction();

    /** Iterates over all examples and all attributes makes callbacks to
     *  {@link #getReplenishmentValue(int, Attribute, double)} if {@link #replenishValue(double)} 
     *  returns true.
     */
    public IOObject[] apply() throws OperatorException {
	ExampleSet eSet = (ExampleSet)getInput(ExampleSet.class);

	int[] replenishmentFunctions = new int[eSet.getNumberOfAttributes()];
	for (int j = 0; j < replenishmentFunctions.length; j++) {
	    replenishmentFunctions[j] = getParameterAsInt("default");
	}
	Iterator i = getParameterList("columns").iterator();
	while (i.hasNext()) {
	    Object[] pair = (Object[])i.next();
	    String  name = (String)pair[0];
	    Integer replenishmentFunctionIndex = (Integer)pair[1];
	    for (int j = 0; j < eSet.getNumberOfAttributes(); j++) {
		if (eSet.getAttribute(j).getName().equals(pair[0])) {
		    replenishmentFunctions[j] = replenishmentFunctionIndex.intValue();
		}
	    }
	}

	ExampleReader reader = eSet.getExampleReader();
	while (reader.hasNext()) {
	    Example example = reader.next();
	    for (int j = 0; j < example.getNumberOfAttributes(); j++) {
		double value = example.getValue(j);
		if (replenishValue(value)) {
		    example.setValue(j, getReplenishmentValue(replenishmentFunctions[j], eSet.getAttribute(j), value));
		}
	    }
	}

	eSet.recalculateAllAttributeStatistics();
	return new IOObject[] { eSet };
    }

    public Class[] getOutputClasses() { return new Class[] { ExampleSet.class }; }
    public Class[] getInputClasses() { return new Class[] { ExampleSet.class }; }

    public List getParameterTypes() {
	List types = super.getParameterTypes();
	ParameterType type = new ParameterTypeCategory("default", "Function to apply to all columns that are not explicitly specified by parameter 'columns'.", getFunctionNames(), getDefaultFunction());
	type.setExpert(false);
	types.add(type);
	types.add(new ParameterTypeList("columns", "List of replacement functions for each column.", 
					new ParameterTypeCategory("replace_with", "The key is the attribute name. The value is the name of function used to replace the missing value.", 
								  getFunctionNames(), getDefaultColumnFunction())));
	return types;
    }
}