generatingmutation.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.features.ga;

import edu.udo.cs.yale.generator.FeatureGenerator;
import edu.udo.cs.yale.generator.GenerationException;
import edu.udo.cs.yale.operator.features.IndividualOperator;
import edu.udo.cs.yale.example.AttributeWeightedExampleSet;
import edu.udo.cs.yale.example.Attribute;
import edu.udo.cs.yale.example.Tools;
import edu.udo.cs.yale.tools.RandomGenerator;
import edu.udo.cs.yale.tools.LogService;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/** The mutation operator for YAGGA. This operator adds single attributes from the original set, 
 *  creates new ones and deselect single attributes.  
 *  @version $Id: GeneratingMutation.java,v 2.16 2004/08/27 11:57:36 ingomierswa Exp $
 *  @see YAGGA */
public class GeneratingMutation extends IndividualOperator {

    private List generators;
    private List originalAttributes;
    private double p;
    private RandomGenerator random = RandomGenerator.getGlobalRandomGenerator();
    private int maxDepth = -1;
    private String[] unusedFunctions = new String[0];

    public GeneratingMutation(List originalAttributes, double p, List generators) {
	this.originalAttributes = originalAttributes;
	this.p = p/4;
	this.generators = generators;
    }

    public void setMaxConstructionDepth(int maxDepth) {
	this.maxDepth = maxDepth;
    }

    public void setUnusedFunctions(String[] functions) {
	this.unusedFunctions = unusedFunctions;
    }

    /** Performs one of the following three mutations:
     *  <ul>
     *    <li>add a newly generated attribute</li>
     *    <li>add an original attribute</li>
     *    <li>remove an attribute</li>
     *  </ul> */
    public List operate(AttributeWeightedExampleSet exampleSet) throws Exception {
	LinkedList l = new LinkedList();
	AttributeWeightedExampleSet clone = (AttributeWeightedExampleSet)exampleSet.clone();

	try {
	    addOriginalAttribute(clone);
	    boolean generationPossible = addGeneratedAttribute(clone);
	    deselect(clone, generationPossible ? 2 : 1);
	} catch (GenerationException e) {
	    LogService.logMessage("GeneratingMutation: Exception occured during generation of attributes, using original example set instead.", LogService.WARNING);
	    l.add(exampleSet);
	}
	
	if (clone.getNumberOfUsedAttributes() > 0) {
	    Iterator i = exampleSet.getUserDataKeys().iterator();
	    while (i.hasNext()) {
		String key = (String)i.next();
		clone.setUserData(key, exampleSet.getUserData(key));
	    }
	    l.add(clone);
	} else {
	    l.add(exampleSet);
	}
	return l;
    }

    /** Adds a new attribute. Returns true, if generation was possible. */
    private boolean addGeneratedAttribute(AttributeWeightedExampleSet exampleSet) throws Exception {
	if (random.nextDouble() < p) {
	    FeatureGenerator generator = FeatureGenerator.selectGenerator(exampleSet, generators, maxDepth, unusedFunctions);
	    if (generator != null) {
		generator = generator.newInstance();
		Attribute[] args = Tools.getRandomCompatibleAttributes(exampleSet, generator, maxDepth, unusedFunctions);
		generator.setArguments(args);
		List generatorList = new LinkedList();
		generatorList.add(generator);
		exampleSet.addAllAttributes(FeatureGenerator.generateAll(exampleSet.getExampleTable(), generatorList));
		return true;
	    } else return false;
	} else return false;
    }

    private void addOriginalAttribute(AttributeWeightedExampleSet exampleSet) {
	if (random.nextDouble() < p) {
	    int i = random.nextInt(originalAttributes.size());
	    Attribute originalAttribute = (Attribute)originalAttributes.get(i);
	    if (exampleSet.getAttribute(originalAttribute.getName()) == null)
		exampleSet.addAttribute(originalAttribute);
	}
    }

    private void deselect(AttributeWeightedExampleSet exampleSet, int m) {
	int n = exampleSet.getNumberOfAttributes();
	for (int i = n-1; i >= 0; i--) {
	    if (random.nextDouble() < m*p/originalAttributes.size()) {
		exampleSet.removeAttribute(i);
	    }
	}
    }
}