dbscanclusteringoperator.java

DBSCAN的Java 数据挖掘 源代码

package xmu.hll.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.Models.Clustering.ClusteringMiningModel;
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.patch.standard.operation.operator.KMeansOperator;
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.IOperatorNode;
import eti.bi.common.Locale.Resource;
import eti.bi.exception.SysException;

public class DBSCANClusteringOperator extends KMeansOperator {
	private static final long serialVersionUID = 1L;
	public static String M_EPS = "eps---";
	public static String M_MINPOTIONS = "minPoints---";
	public static String DEFAULT_M_EPS = "3";
	public static String DEFAULT_M_MINPOTIONS = "2";
	private static String ALGORITHM_NAME = "DBSCAN";
	private static String MAP_EPS = "eps";
	private static String MAP_MINPOTIONS = "minPoints";
	public DBSCANClusteringOperator(String a_CaseID, INodeInfo aNodeInfo, ICaseHandler aCaseHandler) {
        super(a_CaseID, aNodeInfo, aCaseHandler);
	}

	@Override
	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents) throws MiningException, SysException {
		//-------------------------------------------------校验eps
		String eps = a_OperatorNode.getParameterValue(M_EPS);
        if(eps == null) {
        	eps = DEFAULT_M_EPS;
        }
        //-------------------------------------------------校验minPoints
        String minPoints = a_OperatorNode.getParameterValue(M_MINPOTIONS);
        if(minPoints == null) {
        	minPoints = DEFAULT_M_MINPOTIONS;
        }

        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.");
        }
        BIData aOutputBIData = new BIData(getCaseID(), getNodeID());
        aOutputBIData.setTransformActionHistory(aInputBIData.getTransformActionHistory());
        aOutputBIData.setMiningStoredData(aInputBIData.getMiningStoredData());
        BIModel aOutputBIModel = new BIModel(getCaseID(), getNodeID(), 1);
        CDBasedClusteringSettings miningSettings = new CDBasedClusteringSettings();
        miningSettings.setDataSpecification(aInputBIData.getMetaData());
//        Distance dist = new Distance();
//        dist.setType(Integer.parseInt(distanceValue));
//        dist.setBeta(Integer.parseInt(beta));
//        miningSettings.setDistance(dist);
        miningSettings.verifySettings();
        aOutputBIModel.setMiningSettings(miningSettings);
        MiningAlgorithmSpecification miningAlgorithmSpecification = MiningAlgorithmSpecification.getMiningAlgorithmSpecification(ALGORITHM_NAME, getNodeInfo());
        if(miningAlgorithmSpecification == null)
        {
            throw new SysException("Can't find clustering method.");
        }
        String className = miningAlgorithmSpecification.getClassname();
        if(className == null)
        {
            throw new SysException("classname attribute expected.");
        }
		miningAlgorithmSpecification.setMAPValue(MAP_EPS, eps);
		miningAlgorithmSpecification.setMAPValue(MAP_MINPOTIONS, minPoints);
        aOutputBIModel.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
        displayMiningAlgSpecParameters(miningAlgorithmSpecification);
        MiningAlgorithm algorithm = (CDBasedClusteringAlgorithm)GeneralUtils.createMiningAlgorithmInstance(className, getClass().getClassLoader());
        algorithm.setMiningInputStream(aInputBIData.getMiningStoredData());
        algorithm.setMiningSettings(miningSettings);
        algorithm.setMiningAlgorithmSpecification(miningAlgorithmSpecification);
        algorithm.verify();
        MiningModel model = algorithm.buildModel();
        m_SystemMessageHandler.appendMessage((new StringBuilder(String.valueOf(Resource.srcStr("calculationtime")))).append(" [s]: ").append(algorithm.getTimeSpentToBuildModel()).append(Resource.srcStr("ms")).toString());
        m_SystemMessageHandler.nextLine();
        m_SystemMessageHandler.nextLine();
        aOutputBIModel.setMiningModel(model);
        aOutputBIModel.setModelName((new StringBuilder("Clustering_")).append(a_OperatorNode.getNodeID()).toString());
        m_OutputBIObject.setBIData(aOutputBIData);
        m_OutputBIObject.setBIModel(aOutputBIModel);
        com.prudsys.pdm.Models.Clustering.Cluster clusters[] = ((ClusteringMiningModel)model).getClusters();
        aInputBIData.getMiningStoredData().reset();
        clearPredicted();
        clearIntPredicted();
        clearDis();
        double dis;
        for(; aInputBIData.getMiningStoredData().next(); addDistance(new Double(dis)))
        {
            com.prudsys.pdm.Input.MiningVector vector = aInputBIData.getMiningStoredData().read();
            int predicted = (int)model.applyModelFunction(vector);
            addPredicted((new StringBuilder("clust")).append(String.valueOf(predicted)).toString());
            addIntPredicted(new Integer(predicted));
            dis = ((CDBasedClusteringMiningModel)model).getDistance(vector, clusters[predicted]);
        }
	}
	
	public boolean hasResult() {
        if(m_OutputBIObject != null) {
            return m_OutputBIObject.hasResult(BIObject.DATA) && m_OutputBIObject.hasResult(BIObject.MODEL);
        } 
        else {
            return false;
        }
    }

}