randomoptimizationchain.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;

import java.util.List;

import edu.udo.cs.yale.example.ExampleSet;
import edu.udo.cs.yale.operator.parameter.ParameterTypeInt;
import edu.udo.cs.yale.operator.performance.PerformanceVector;

/**
 * This operator iterates several times through the inner operators and in each cycle evaluates a performance measure. 
 * The IOObjects that are produced as output of the inner operators in the best cycle are then returned.
 * The target of this operator are methods that involve some non-deterministic elements such that the performance in each 
 * cycle may vary. An example is k-means with random intialization.
 * 
 * @author Michael Wurst
 * @version $Id: RandomOptimizationChain.java,v 1.1 2004/10/08 08:05:02 mjwurst Exp $
 */
public class RandomOptimizationChain extends OperatorChain {

	 private int iteration;
	    
	    public RandomOptimizationChain() {
		addValue(new Value("iteration", "The number of the current iteration.") {
			public double getValue() {
			    return iteration;
			}
		    });
	    }
	
	public IOObject[] apply() throws OperatorException {

		int numCycles = getParameterAsInt("iterations");
		
		iteration = 0;
		double maxValue = Double.NEGATIVE_INFINITY;
		IOContainer bestResult = null;
		for (int i = 0; i < numCycles; i++) {

			IOContainer io = applyInnerLoop();
			
			PerformanceVector perf = (PerformanceVector) io.getInput(
					PerformanceVector.class, true);

			if (perf.getMainCriterion().getFitness() > maxValue) {

				maxValue = perf.getMainCriterion().getFitness();
				bestResult = io;
			}
			
			iteration++;
		}

		// TODO: Delete the whole input container in a nicer way than this
		
		try {
			while(getInput(IOObject.class, true) != null);
		} catch (MissingIOObjectException e) {
		}
				
		return bestResult.getIOObjects();
	}

	/**
	 * Applies the inner operator .
	 */
	private IOContainer applyInnerLoop() throws OperatorException {

		IOContainer container = getInput().copy();
		for(int i = 0; i < getNumberOfOperators(); i++) {
			container = getOperator(i).apply(container);
		}
		
		return container;
	}

	public Class[] getInputClasses() {
		return new Class[0];
	}

	public Class[] getOutputClasses() {
		return new Class[0];
	}

	public Class[] checkIO(Class[] input) throws IllegalInputException {
		for (int i = 0; i < getNumberOfOperators(); i++) {
			Operator o = getOperator(i);
			input = o.checkIO(input);
		}
		
		if(!IODescription.containsClass(PerformanceVector.class, input))
			throw new IllegalInputException(this, "The inner operators of RandomOptimizer must return a PerformanceVector");
		
		return input;
	}

	/**
	 * Returns the highest possible value for the maximum number of innner
	 * operators.
	 */
	public int getMaxNumberOfInnerOperators() {
		return Integer.MAX_VALUE;
	}

	/** Returns 1 for the minimum number of innner operators. */
	public int getMinNumberOfInnerOperators() {
		return 1;
	}

	public int getNumberOfSteps() {
		return getNumberOfChildrensSteps();
	}

	public List getParameterTypes() {
		List types = super.getParameterTypes();

		types.add(new ParameterTypeInt("iterations", "The number of iterations to perform", 10,
				Integer.MAX_VALUE, false));
		return types;
	}

}