dbscanclusteringoperator.java

数据挖掘

package edu.xmu.operation.operator;

import java.util.Vector;

import com.prudsys.pdm.Core.CategoricalAttribute;
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.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.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.patch.standard.operation.operator.KMeansOperator;
import eti.bi.alphaminer.vo.BIData;
import eti.bi.alphaminer.vo.BIModel;
import eti.bi.alphaminer.vo.IBIData;
import eti.bi.alphaminer.vo.IBIModel;
import eti.bi.alphaminer.vo.IBIObject;
import eti.bi.alphaminer.vo.IOperatorNode;
import eti.bi.common.Locale.Resource;
import eti.bi.exception.SysException;

public class DBScanClusteringOperator extends KMeansOperator {
	private static final long serialVersionUID = -5737108576656740502L;

	public DBScanClusteringOperator(String a_CaseID, INodeInfo aNodeInfo,
			ICaseHandler aCaseHandler) {
		super(a_CaseID, aNodeInfo, aCaseHandler);
		// TODO Auto-generated constructor stub
	}

	/* Parameter name for Clustering 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 EPS_NUMBER = "Eps Number";

	public static String MINPTS_NUMBER = "Minpts Number";

	/* Default parameter value for Clustering 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_EPS_NUMBER = "30.0";

	public static String DEFAULT_MINPTS_NUMBER = "2";

	/* Parameter name for MiningSettingSpecification and MiningAlgorithm */
	private static String ALGORITHM_NAME = "DBscanClustering";
	private static String MAP_EPS_NUMBER = "Epslion";
	private static String MAP_MINPTS_NUMBER = "minNumberOfPoints";

	/* Vectors storing Clustering model statistics */
	private Vector m_Predicted;

	/* variable used in statistics, store the int value of the predicted result */
	private Vector m_IntPredicted;
	private Vector m_Distances;

	/**
	 * Set node id and update operator text of the DecisionTreeOperator at the
	 * same time.
	 * 
	 * @param a_NodeID
	 *            ID of the node
	 */
	@Override
	public void setNodeID(String a_NodeID) {
		setLabel(getDescription() + " [" + a_NodeID + "]");
		setDefaultModelName("K-Means_" + a_NodeID);
		super.setNodeID(a_NodeID);
	}

	/**
	 * Set node id and update operator text of the DecisionTreeOperator at the
	 * same time.
	 * 
	 * @param a_Description
	 */
	@Override
	public void setDescription(String a_Description) {
		m_Description = a_Description;
		setLabel(m_Description + " [" + m_NodeID + "]");
		setDefaultModelName("K-Means_" + m_NodeID);
	}

	/**
	 * Gets the predicted values.
	 * 
	 * @return a vector storing predicted values.
	 */
	@Override
	public Vector getPredicted() {
		return m_Predicted;
	}

	/**
	 * Gets the predicted values (integers).
	 * 
	 * @return a vector storing predicted valeus (integers).
	 */
	@Override
	public Vector getIntPredicted() {
		return m_IntPredicted;
	}

	/**
	 * Clear the stored predicted values.
	 */
	@Override
	public void clearPredicted() {
		m_Predicted = null;
	}

	/**
	 * Clear the stored predicted values (integers).
	 */
	@Override
	public void clearIntPredicted() {
		m_IntPredicted = null;
	}

	/**
	 * Clear the stored distance values.
	 */
	@Override
	public void clearDis() {
		m_Distances = null;
	}

	/**
	 * Add an entry of predicted cluster.
	 * 
	 * @param predict
	 *            the predicted cluster.
	 */
	@Override
	@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
	 */
	@Override
	@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
	 */
	@Override
	@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.
	 */
	@Override
	public boolean hasResult() {
		if (m_OutputBIObject != null) {
			return (m_OutputBIObject.hasResult(IBIObject.DATA) && m_OutputBIObject
					.hasResult(IBIObject.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.
	 */
	@Override
	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents)
			throws MiningException, SysException {
		/* Get parameter from user input */
		String distanceValue = a_OperatorNode.getParameterValue(DISTANCE_TYPE);
		if (distanceValue == null) {
			distanceValue = DEFAULT_DISTANCE_TYPE;
		}
		String functionValue = a_OperatorNode
				.getParameterValue(COMPARE_FUNCTION);
		if (functionValue == null) {
			functionValue = DEFAULT_COMPARE_FUNCTION;
		}
		String measureValue = a_OperatorNode.getParameterValue(MEASURE);
		if (measureValue == null) {
			measureValue = DEFAULT_MEASURE;
		}
		String normalizeValue = a_OperatorNode.getParameterValue(NORMALIZE);
		if (normalizeValue == null) {
			normalizeValue = DEFAULT_NORMALIZE;
		}
		String numMinpts = a_OperatorNode.getParameterValue(MINPTS_NUMBER);
		if (numMinpts == null) {
			numMinpts = DEFAULT_MINPTS_NUMBER;
		}
		String numIterationValue = a_OperatorNode
				.getParameterValue(ITERATION_NUMBER);
		if (numIterationValue == null) {
			numIterationValue = DEFAULT_ITERATION_NUMBER;
		}

		String numEps = a_OperatorNode.getParameterValue(EPS_NUMBER);
		if (numEps == null)
			numEps = DEFAULT_EPS_NUMBER;

		/* 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_CLASSIFIER);

		/* Execure Clustering Model Building */
		/* Create MiningSettings object and assign metadata */
		CDBasedClusteringSettings miningSettings = new CDBasedClusteringSettings();
		MiningAttribute miningAttributes[] = aInputBIData.getMetaData()
				.getAttributesArray();
		// Work around: Clustering algorithm does not produce valid result for
		// cat. attribute, so pop up a warning
		// Message.
		boolean isContainCats = false;

		for (int i = 0; i < miningAttributes.length; i++) {
			if (miningAttributes[i] instanceof CategoricalAttribute) {
				isContainCats = true;
			}
		}

		if (isContainCats) {
			m_MessageDialog
					.showWarning(
							"Categorical attributes are not supported and will be ignored in building cluster.",
							"Warning");
		}
		miningSettings.setDataSpecification(aInputBIData.getMetaData());

		/* Assign settings */
		Distance dist = new Distance();
		dist.setType(Integer.parseInt(distanceValue));
		dist.setCompareFunction(Integer.parseInt(functionValue));
		dist.setMeasureType(Integer.parseInt(measureValue));

		boolean norm = false;
		if (normalizeValue.equals(String.valueOf(true))) {
			norm = true;
		}
		dist.setNormalized(norm);

		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_MINPTS_NUMBER, numMinpts);
		miningAlgorithmSpecification.setMAPValue(MAP_EPS_NUMBER, numEps);
		aOutputBIModel
				.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
		displayMiningAlgSpecParameters(miningAlgorithmSpecification);

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

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

	//	m_SystemMessageHandler.appendLineMessage("Minpts " + ((MDBscan)algorithm).getMinPts());
		/* 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();
		/*
		 * Apply the model to get the cluster and distance information. By
		 * TWang. Jan 19, 2005.
		 */
		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.
	 */
	@Override
	public Vector getDistances() {
		return m_Distances;
	}

	/**
	 * @param distances
	 *            The m_Distances to set.
	 */
	@Override
	public void setDistances(Vector distances) {
		m_Distances = distances;
	}

}