fwkmeansclusteringoperator.java

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

/**
 * @author XiaoGuang Xu in HITSZ-ICE
 */
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.MiningException;
import com.prudsys.pdm.Core.MiningModel;
import com.prudsys.pdm.Input.MiningVector;
import com.prudsys.pdm.Models.Clustering.Cluster;
import com.prudsys.pdm.Models.Clustering.ClusteringMiningModel;
import com.prudsys.pdm.Models.Clustering.Distance;
import com.prudsys.pdm.Models.Clustering.CDBased.CDBasedClusteringAlgorithm;
import com.prudsys.pdm.Models.Clustering.CDBased.CDBasedClusteringMiningModel;
import com.prudsys.pdm.Models.Clustering.CDBased.CDBasedClusteringSettings;
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.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.SysException;

/**
 * implementation of an automated variable weighting in k-means type clustering 
 * algorithm.
 */
public class FWKMeansClusteringOperator extends KMeansOperator {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 12L;

	/**
	 * @param a_CaseID
	 * @param a_CaseWindow
	 * @param aOperatorInfo
	 */
	public FWKMeansClusteringOperator(String a_CaseID, INodeInfo aNodeInfo, ICaseHandler aCaseHandler) {
		super(a_CaseID, aNodeInfo, aCaseHandler);
		// TODO Auto-generated constructor stub
	}

	/* Parameter name for FWKMeansClustering Operator in BIML */
	public static String DISTANCE_TYPE = "Distance type";
	public static String COMPARE_FUNCTION = "Compare function";
	public static String MEASURE = "Measure";
	public static String NORMALIZE = "Normalize";
	public static String CLUSTER_NUMBER = "Cluster number";
	public static String ITERATION_NUMBER = "Iteration number";
	public static String IS_WEIGHT = "Is Weight";
	public static String BETA = "beta";
	public static String ALPHA="alpha";
	/* Default parameter value for  FWKMeansClustering Operator */
	public static String DEFAULT_DISTANCE_TYPE = String.valueOf(Distance.TYPE_EUCLIDEAN);
	public static String DEFAULT_COMPARE_FUNCTION = String.valueOf(Distance.COMPARISON_FUNCTION_ABS_DIFF);
	public static String DEFAULT_MEASURE = String.valueOf(Distance.MEASURE_TYPE_DISTANCE);
	public static String DEFAULT_NORMALIZE = String.valueOf(false);
	public static String DEFAULT_CLUSTER_NUMBER = "3";
	public static String DEFAULT_ITERATION_NUMBER = "100";
	public static String DEFAULT_IS_WEIGHT = String.valueOf(true);		
	public static String DEFAULT_BETA = "8";		
	public static String DEFAULT_ALPHA = "2.0";	
	/* Parameter name for MiningSettingSpecification and MiningAlgorithm */
	private static String ALGORITHM_NAME = "FWKMeans";
	private static String MAP_CLUSTER_NUMBER = "numberOfClusters";
	private static String MAP_ALPHA = "alpha";
	private static String MAP_IS_WEIGHT= "weight";
	/* Vectors storing Clustering model statistics */
	private Vector m_Predicted;
	
	
	private Vector m_IntPredicted;
	private Vector m_Distances;
	/**
	 * End Twang.
	 */

	/**
	 * 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("Association_" + 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("Association_" + m_NodeID);
	}
	
	/**
	 * Gets the predicted values.
	 * @return a vector storing predicted values.
	 */
	public Vector getPredicted() {
		return m_Predicted;
	}
	
	/**
	 * Gets the predicted values (integers).
	 * @return a vector storing predicted valeus (integers).
	 */
	public Vector getIntPredicted() {
		return m_IntPredicted;
	} 
	
	/**
	 * Clear the stored predicted values.
	 */
	public void clearPredicted()
	{
		m_Predicted = null;
	}
	
	/**
	 * Clear the stored predicted values (integers).
	 */
	public void clearIntPredicted()
	{
		m_IntPredicted = null;
	}
	
	/**
	 * Clear the stored distance values.
	 */
	public void clearDis(){
		m_Distances = null;
	}
	
	/**
	 * Add an entry of predicted cluster. 
	 * @param predict the predicted cluster.
	 */
	@SuppressWarnings("unchecked")
	public void addPredicted(String predict) {
		if (m_Predicted==null)
			m_Predicted = new Vector();
			
		if (predict==null)
			predict = "";
		m_Predicted.addElement(predict);	
	}
	
	/**
	 * If the predict value is -1, it means the result is not applicable
	 * @param predict
	 */
	@SuppressWarnings("unchecked")
	public void addIntPredicted(Integer predict) {
		if (m_IntPredicted==null)
			m_IntPredicted = new Vector();
			
		if (predict==null)
			predict = new Integer("-1");
		m_IntPredicted.addElement(predict);	
	}
	
	/**
	 * If the predict value is -1, it means the result is not applicable
	 * @param dis
	 */
	@SuppressWarnings("unchecked")
	public void addDistance(Double dis) {
		if (m_Distances == null)
			m_Distances = new Vector();
			
		if (dis == null)
			dis = new Double("-1");
		m_Distances.addElement(dis); 
	}
	
	/**
	 * Test if the Clustering Operator contains any results.
	 * @return true if Clustering Operator has result; false otherwise.
	 */
	public boolean hasResult()
	{
		if (m_OutputBIObject != null)
		{
			return (m_OutputBIObject.hasResult(BIObject.DATA) &&
					m_OutputBIObject.hasResult(BIObject.MODEL));
		}else
		{
			return false;
		}
	}
	
	/**
	 * Build clustering model for this Clustering Operator.
	 * @param a_OperatorNode Operator Node represented by this Clustering Operator.
	 * @param a_Parents a Vector storing node IDs of parent nodes of this Clustering Operator.
	 */
	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents)
		throws MiningException, SysException
	{				
		/* Get parameter from user input */
		String distanceValue = (String) a_OperatorNode.getParameterValue(DISTANCE_TYPE);
		if (distanceValue==null)
		{
			distanceValue = DEFAULT_DISTANCE_TYPE;
		}
		String functionValue = (String) a_OperatorNode.getParameterValue(COMPARE_FUNCTION);
		if (functionValue==null)
		{
			functionValue = DEFAULT_COMPARE_FUNCTION;
		}
		
		
		String numClusterValue = (String) a_OperatorNode.getParameterValue(CLUSTER_NUMBER);
		if (numClusterValue==null)
		{
			numClusterValue = DEFAULT_CLUSTER_NUMBER;
		}
		
		String isWeight = (String) a_OperatorNode.getParameterValue(IS_WEIGHT);
		if(isWeight==null)
		{
			 isWeight=DEFAULT_IS_WEIGHT ;
		}
		
		String beta = (String) a_OperatorNode.getParameterValue(BETA);
		if(beta==null)
		{
			beta=DEFAULT_BETA;
		}
		String alpha= (String) a_OperatorNode.getParameterValue(ALPHA);
		if(alpha==null)
		{
			alpha=DEFAULT_ALPHA;
		}
		/* Get input bi object from parent node */
		Operator parentOp = (Operator)a_Parents.elementAt(0);
		setInputBIObject(parentOp.getOutputBIObject());
		IBIData aInputBIData = getInputBIObject().getBIData();
		aInputBIData.getMiningStoredData().reset();

		if(!aInputBIData.hasResult()){
			throw new SysException( "No data inputed." );
		}
		
		/* 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_CLUSTERING);

		/* Execure Clustering Model Building */
		/* Create MiningSettings object and assign metadata */
		CDBasedClusteringSettings miningSettings = new CDBasedClusteringSettings();
        miningSettings.setDataSpecification(aInputBIData.getMetaData());

		/* Assign settings */
		Distance dist = new Distance();
		dist.setType(Integer.parseInt(distanceValue));
		dist.setBeta(Integer.parseInt(beta));
		
		miningSettings.setDistance( dist );
		miningSettings.verifySettings();
		aOutputBIModel.setMiningSettings(miningSettings);

		/* Get default mining algorithm specification from 'algorithms.xml': */
		MiningAlgorithmSpecification miningAlgorithmSpecification = 
			MiningAlgorithmSpecification.getMiningAlgorithmSpecification( ALGORITHM_NAME ,getNodeInfo());

		if( miningAlgorithmSpecification == null )
		{
			throw new SysException( "Can't find clustering method." );
		}
		
		/* Get class name from algorithms specification */
		String className = miningAlgorithmSpecification.getClassname();
		if( className == null )
		{
		  throw new SysException( "classname attribute expected." );
		}
		
		/* Set and display mining parameters */
		miningAlgorithmSpecification.setMAPValue(MAP_CLUSTER_NUMBER, numClusterValue);
		miningAlgorithmSpecification.setMAPValue(MAP_ALPHA, alpha);
		miningAlgorithmSpecification.setMAPValue(MAP_IS_WEIGHT, isWeight);
		aOutputBIModel.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
		displayMiningAlgSpecParameters(miningAlgorithmSpecification);

		/* Create algorithm object with default values */
		MiningAlgorithm algorithm = (CDBasedClusteringAlgorithm)
			GeneralUtils.createMiningAlgorithmInstance(className, this.getClass().getClassLoader());

		/* Put it all together */
		algorithm.setMiningInputStream( aInputBIData.getMiningStoredData() );
		algorithm.setMiningSettings( miningSettings );
		algorithm.setMiningAlgorithmSpecification( miningAlgorithmSpecification );
		algorithm.verify();

		/* Build the mining model */
		MiningModel model = algorithm.buildModel();
		m_SystemMessageHandler.appendMessage(Resource.srcStr("calculationtime")+" [s]: " + algorithm.getTimeSpentToBuildModel()+Resource.srcStr("ms"));
		m_SystemMessageHandler.nextLine();
		m_SystemMessageHandler.nextLine();

		/* set output mining data and model to the output mining object */ 
		aOutputBIModel.setMiningModel(model);
		aOutputBIModel.setModelName("Clustering_"+a_OperatorNode.getNodeID());
		m_OutputBIObject.setBIData(aOutputBIData);	
		m_OutputBIObject.setBIModel(aOutputBIModel);

		/* set run time parameter value to the node object (It needs to be stored in the BIML) */
		//a_OperatorNode.setParameterValue("Temporary model", aOutputBIModel.getTempBIModelPath());		

		//aOutputBIModel.writeTempBIModel();

		 
		Cluster[] clusters = ((ClusteringMiningModel)model).getClusters();
		 
		aInputBIData.getMiningStoredData().reset();
		clearPredicted();
		clearIntPredicted();
		clearDis();
		while (aInputBIData.getMiningStoredData().next()) {
		  // Make prediction:
		  MiningVector vector = aInputBIData.getMiningStoredData().read();
		  
		  int predicted       = (int) model.applyModelFunction(vector);
		  addPredicted("clust"+String.valueOf(predicted));
		  addIntPredicted(new Integer(predicted)); 
		  
		  double dis = ((CDBasedClusteringMiningModel)model).getDistance(vector, clusters[predicted]);
		  addDistance(new Double(dis));
		};
	}
	
	/**
	 * @return Returns the m_Distances.
	 */
	public Vector getDistances() {
		return m_Distances;
	}
	
	/**
	 * @param distances The m_Distances to set.
	 */
	public void setDistances(Vector distances) {
		m_Distances = distances;
	}
}