multilayerperceptronoperator.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

package eti.bi.alphaminer.patch.standard.operation.operator;

import java.util.Vector;
import com.prudsys.pdm.Core.MiningAlgorithm;
import com.prudsys.pdm.Core.MiningAlgorithmSpecification;
import com.prudsys.pdm.Core.MiningAttribute;
import com.prudsys.pdm.Core.MiningException;
import com.prudsys.pdm.Core.MiningModel;
import com.prudsys.pdm.Core.NumericAttribute;
import com.prudsys.pdm.Models.Supervised.SupervisedMiningSettings;
import com.prudsys.pdm.Utils.GeneralUtils;
import eti.bi.alphaminer.core.handler.ICaseHandler;
import eti.bi.alphaminer.operation.operator.INodeInfo;
import eti.bi.alphaminer.operation.operator.ModelOperator;
import eti.bi.alphaminer.operation.operator.Operator;
import eti.bi.alphaminer.vo.BIData;
import eti.bi.alphaminer.vo.BIModel;
import eti.bi.alphaminer.vo.BIObject;
import eti.bi.alphaminer.vo.IBIData;
import eti.bi.alphaminer.vo.IBIModel;
import eti.bi.alphaminer.vo.IOperatorNode;
import eti.bi.common.Locale.Resource;
import eti.bi.exception.AppException;
import eti.bi.exception.SysException;

public class MultilayerPerceptronOperator extends ModelOperator{
	/* Parameter name for NavieBayes Operator in BIML */
	public static String GUI = "gui";
	public static String AUTOBUILD = "autoBuild";
	public static String DECAY = "decay";
	public static String HIDDENLAYERS = "hiddenLayers";
	public static String LEARNINGRATE = "learningRate";
	public static String MOMENTUM = "momentum";
	public static String NOMINALTOBINARYFILTER = "nominalToBinaryFilter";
	public static String NORMALIZEATTRIBUTES = "normalizeAttributes";
	public static String NORMALIZENUMERICCLASS = "normalizeNumericClass";
	public static String RANDOMSEED = "randomSeed";
	public static String RESET = "reset";
	public static String TRAININGTIME = "trainingTime";
	public static String VALIDATIONSETSIZE = "validationSetSize";
	public static String VALIDATIONTHRESHOLD = "validationThreshold";
	
	
	
	public static String DEFAULT_GUI = "";
	public static String DEFAULT_autoBuild = "";
	public static String DEFAULT_decay = "";
	
	public static String DEFAULT_hiddenLayers = "1";
	
	public static String DEFAULT_learningRate = "0.3";
	public static String DEFAULT_momentum = "0.2";
	public static String DEFAULT_nominalToBinaryFilter = "";
	public static String DEFAULT_normalizeAttributes = "";
	public static String DEFAULT_normalizeNumericClass = "";
	public static String DEFAULT_randomSeed = "0";
	public static String DEFAULT_reset = "";
	public static String DEFAULT_trainingTime = "500";
	public static String DEFAULT_validationSetSize = "0";
	public static String DEFAULT_validationThreshold = "20";
	
	/* Parameter name for MiningSettingSpecification and MiningAlgorithm */
	public static final String ALGORITHM_NAME = "MultilayerPerceptron (Weka)";
	private static String MAP_WEKA_CLASS_PARAMETERS = "wekaClassParameters";
	
	
	
	/**
	 * @param a_CaseID
	 * @param a_CaseWindow
	 * @param aOperatorInfo
	 */
	public MultilayerPerceptronOperator(String a_CaseID, INodeInfo aNodeInfo, ICaseHandler aCaseHandler) {
		super(a_CaseID, aNodeInfo, aCaseHandler);
		setDefaultModelName(Resource.srcStr("MultilayerPerceptron"));
		//2006/07/29 Xiaojun Chen
		PredictionAssessmentOperator.registerParentsDefinitionID(aNodeInfo.getDefinitionID());
		ScoreOperator.registerParentsDefinitionID(aNodeInfo.getDefinitionID());
	}

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/**
	 * Set node id and update operator text of the DecisionTreeOperator at the same time.
	 * @param a_NodeID ID of the node
	 */
	public void setNodeID(String a_NodeID) {
		setLabel(getDescription() + " [" + a_NodeID + "]");
		setDefaultModelName(Resource.srcStr("MultilayerPerceptron")+"_" + a_NodeID);
		super.setNodeID(a_NodeID);
	}
	
	/**
	 * Set node id and update operator text of the DecisionTreeOperator at the same time.
	 * @param a_NodeID ID of the node
	 */
	public void setDescription(String a_Description) {
		m_Description = a_Description;
		setLabel(m_Description + " [" + m_NodeID + "]");
		setDefaultModelName(Resource.srcStr("MultilayerPerceptron")+"_" + m_NodeID);
	}

	
	@SuppressWarnings("unchecked")
	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents)
			throws SysException, AppException, MiningException {
		
		
		String gui = (String) a_OperatorNode.getParameterValue(GUI);
		if (gui == null) {
			gui = DEFAULT_GUI;
		}

		String autoBuild = (String) a_OperatorNode.getParameterValue(AUTOBUILD);
		if (autoBuild == null) {
			autoBuild = DEFAULT_autoBuild;
		}
		String decay = (String) a_OperatorNode.getParameterValue(DECAY);
		if (decay == null) {
			decay = DEFAULT_decay;
		}
		String hiddenLayers = (String) a_OperatorNode.getParameterValue(HIDDENLAYERS);
		if (hiddenLayers == null) {
			hiddenLayers = DEFAULT_hiddenLayers;
		}
		String learningRate = (String) a_OperatorNode.getParameterValue(LEARNINGRATE);
		if (learningRate == null) {
			learningRate = DEFAULT_learningRate;
		}
		String momentum = (String) a_OperatorNode.getParameterValue(MOMENTUM);
		if (momentum == null) {
			momentum = DEFAULT_momentum;
		}
		String nominalToBinaryFilter = (String) a_OperatorNode.getParameterValue(NOMINALTOBINARYFILTER);
		if (nominalToBinaryFilter == null) {
			nominalToBinaryFilter = DEFAULT_nominalToBinaryFilter;
		}
		String normalizeAttributes = (String) a_OperatorNode.getParameterValue(NORMALIZEATTRIBUTES);
		if (normalizeAttributes == null) {
			normalizeAttributes = DEFAULT_normalizeAttributes;
		}
		
		String normalizeNumericClass = (String) a_OperatorNode.getParameterValue(NORMALIZENUMERICCLASS);
		if (normalizeNumericClass == null) {
			normalizeNumericClass = DEFAULT_normalizeNumericClass;
		}
		
		String randomSeed = (String) a_OperatorNode.getParameterValue(RANDOMSEED);
		if (randomSeed == null) {
			randomSeed = DEFAULT_randomSeed;
		}
		
		String reset = (String) a_OperatorNode.getParameterValue(RESET);
		if (reset == null) {
			reset = DEFAULT_reset;
		}
		
		String trainingTime = (String) a_OperatorNode.getParameterValue(TRAININGTIME);
		if (trainingTime == null) {
			trainingTime = DEFAULT_trainingTime;
		}
		
		String validationSetSize = (String) a_OperatorNode.getParameterValue(VALIDATIONSETSIZE);
		if (validationSetSize == null) {
			validationSetSize = DEFAULT_validationSetSize;
		}
		
		String validationThreshold = (String) a_OperatorNode.getParameterValue(VALIDATIONTHRESHOLD);
		if (validationThreshold == null) {
			validationThreshold = DEFAULT_validationThreshold;
		}
		
		
		String multilayerPerceptronOperatorParameters = "-L "+learningRate+" -N "+" "+trainingTime +" -M "+" "+ momentum+" "+" -V "+" "+validationSetSize+" "+"-S"+" "+randomSeed+" "+"-E"+
		" "+validationThreshold+" "+" -H "+hiddenLayers + autoBuild +nominalToBinaryFilter + normalizeNumericClass + normalizeAttributes + reset +decay + gui;
		
		
		
		/* Get input bi object from parent node */
		Operator parentOp = (Operator)a_Parents.elementAt(0);
		setInputBIObject(parentOp.getOutputBIObject());
		IBIData aInputBIData = getInputBIObject().getBIData();
		aInputBIData.getMiningStoredData().reset();
		
		/* Prepare output data model */
		BIData aOutputBIData = new BIData(getCaseID(), getNodeID());
		aOutputBIData.setTargetAttribute(aInputBIData.getTargetAttribute());
		aOutputBIData.setTransformActionHistory(aInputBIData.getTransformActionHistory());
		aOutputBIData.setTargetAttribute(aInputBIData.getTargetAttribute());
		aOutputBIData.setMiningStoredData(aInputBIData.getMiningStoredData());
		BIModel aOutputBIModel = new BIModel(getCaseID(), getNodeID(), IBIModel.TYPE_CLASSIFIER);
		
		/* Check attributes */
		MiningAttribute targetAttribute = aInputBIData.getTargetAttribute();
		aOutputBIModel.setTargetAttribute(targetAttribute);
		if (targetAttribute==null)
		{
			throw new AppException("Categorical Target attribute is missing. Please add target attribute by using Data Set Attribute Node.");
		}else if (targetAttribute instanceof NumericAttribute)
		{
			m_SystemMessageHandler.appendMessage("Attribute \""+targetAttribute.getName() + "\" is not Categorical.");
			throw new AppException("Attribute \""+targetAttribute.getName() + "\" should be Categorical.");
		}
		
		/*Create MiningSettings object and assign metadata*/
		SupervisedMiningSettings miningSettings = new SupervisedMiningSettings();
		miningSettings.setDataSpecification(aInputBIData.getMetaData());
		
		 /* Assign settings */
	    miningSettings.setTarget(targetAttribute);
	    try {
	    	miningSettings.verifySettings();
	    } catch (Exception e)
		{
	    	m_SystemMessageHandler.appendMessage("Invalid parameters in building the Decision Tree model.");
	    	throw new AppException("Invalid parameters in building the Decision Tree model.");
	    }	    
		
	    /* Set MiningSettings */
		aOutputBIModel.setMiningSettings(miningSettings);
		/* Get default mining algorithm specification from 'algorithms.xml' */
	    MiningAlgorithmSpecification miningAlgorithmSpecification =
	    MiningAlgorithmSpecification.getMiningAlgorithmSpecification( ALGORITHM_NAME,getNodeInfo());
	    
	    if( miningAlgorithmSpecification == null )
		      throw new MiningException( "Can't find MultilayerPerceptron classification method." );
	    
	    /* Get class name from algorithms specification */
	    String className = miningAlgorithmSpecification.getClassname();
	    if( className == null )
	      throw new MiningException( "className attribute expected." );
	    
	    /* Set MiningAlgorithmSpecification */
		miningAlgorithmSpecification.setMAPValue(MAP_WEKA_CLASS_PARAMETERS, multilayerPerceptronOperatorParameters);
		aOutputBIModel.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
		displayMiningAlgSpecParameters(miningAlgorithmSpecification);
	    
		 /* Set and display mining parameters */
	    GeneralUtils.displayMiningAlgSpecParameters(miningAlgorithmSpecification);
	    
	    /* Create algorithm object with default values */
	    MiningAlgorithm algorithm = GeneralUtils.createMiningAlgorithmInstance(className, this.getClass().getClassLoader());
						
		algorithm.setMiningInputStream(aInputBIData.getMiningStoredData());
		algorithm.setMiningSettings(miningSettings);
		algorithm.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
		try
		{
			algorithm.verify();
		} catch(IllegalArgumentException e)
		{
			throw new MiningException(e.getMessage());
		}
		
		MiningModel model = algorithm.buildModel();
		
		m_SystemMessageHandler.appendMessage(Resource.srcStr("calculationtime")+" [s]: " + algorithm.getTimeSpentToBuildModel()+Resource.srcStr("ms"));
		m_SystemMessageHandler.nextLine();
		
		aOutputBIModel.setMiningModel(model);
		aOutputBIModel.setModelName(m_DefaultModelName);
		
		m_OutputBIObject.setBIData(aOutputBIData);	
		m_OutputBIObject.setBIModel(aOutputBIModel);
		
		//a_OperatorNode.setParameterValue("Temporary model", aOutputBIModel.getTempBIModelPath());		
		
		//aOutputBIModel.writeTempBIModel();
		
	}

	/**
	 * Test if the NavieBayes Operator contains any results.
	 * @return true if NavieBayes Operator has result; false otherwise.
	 */
	public boolean hasResult() throws SysException {
		
		if (m_OutputBIObject != null)
		{
			return (m_OutputBIObject.hasResult(BIObject.DATA) &&
					m_OutputBIObject.hasResult(BIObject.MODEL));
		}else
		{
			return false;
		}
		
	}
	
}