datasetattributesoperator.java

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

	    mapping.setTargetName(a_Target);
	    
		return mapping;
	}

	public Numerization preparecNumerization(String a_Target)
	{
	    Numerization mapping = new Numerization();
		
		mapping.setSourceName(a_Target);
        mapping.setTargetName(a_Target);
		
        return mapping;
	}
	
	public boolean hasResult()
	{
		if (m_OutputBIObject != null)
		{
			return (m_OutputBIObject.hasResult(BIObject.DATA));
		}else
		{
			return false;
		}
	}

	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents)
		throws MiningException, SysException, AppException
	{
		
		/* Get input bi object from parent node */
		Operator parentOp = (Operator)a_Parents.elementAt(0);
		setInputBIObject(parentOp.getOutputBIObject());
		IBIData aInputBIData = getInputBIObject().getBIData();
		
		
		/* Get parameter from user input */
		boolean valid = validateParameters(aInputBIData.getMetaData(),a_OperatorNode);
		String aTargetAttrName = (String) a_OperatorNode.getParameterValue(DataSetAttributesOperatorProperty.TARGET_TAG);
		
		
		/* Prepare output mining data */
		//aOutputMiningStoredData.reset();
		BIData aOutputBIData = new BIData(getCaseID(), getNodeID());
		aOutputBIData.copyTransformActionHistory(aInputBIData.getTransformActionHistory());
			
		if(valid){
			/* execute this node */
			//1. Remove unused attribute
			MiningTransformationFactory mtf1 = new MiningTransformationFactory();
			RemoveAttributes removeAttributes = prepareRemoveAttributes(aInputBIData.getMetaData(),a_OperatorNode);
			MiningTransformationStep mts1 = null;
			MiningStoredData msd1 = null;
			if (removeAttributes.getRemoveAttributeNames().size()>0)
			{
				mtf1.addMultipleToMultipleMapping(removeAttributes);
				mts1 = mtf1.createMiningTransformationStep();
				XelopesTransformAction action1 = new XelopesTransformAction(m_CaseID, m_NodeID, mts1);
				msd1 = action1.transform(aInputBIData.getMiningStoredData());
				
				/* Not adding remove attribute (M-to-M) to transformation history.
				 Workaround the problem that the scoring data set doesn't contains
				 the target attribute would cause problem. As M-to-M transformation needs
				 all the attributes.*/ 
				//Logistic model will run into problem if remove history is not remembered
				//whiling scoring another data set will missing values.
				aOutputBIData.addTransformActionHistory(action1);
			}else
			{
				msd1 = aInputBIData.getMiningStoredData();
			}
			
			//2. Transform mining attribute type (ie Categorical->Numeric, Numeric -> Categorical)
			MiningStoredData msd2 = null;
			MiningTransformationFactory mtf2 = new MiningTransformationFactory();
			mtf2 = prepareTypeTransformation(aInputBIData.getMetaData(),a_OperatorNode, mtf2);
			if(mtf2!=null){
				MiningTransformationStep mts2 = mtf2.createMiningTransformationStep();
				XelopesTransformAction action2 = new XelopesTransformAction(m_CaseID, m_NodeID, mts2);
				msd2 = action2.transform(msd1);
				aOutputBIData.addTransformActionHistory(action2);
			}else
			{
				msd2 = msd1;
			}
			
			//3. Transform mining attribute type (ie Categorical->Numeric, Numeric -> Categorical)
	//		MiningTransformationFactory mtf3 = new MiningTransformationFactory();
	//		prepareDataTypeTransformation(aInputBIData.getMetaData(),a_OperatorNode, mtf3);
	//		MiningTransformationStep mts3 = mtf3.createMiningTransformationStep();
	//		XelopesTransformAction action3 = new XelopesTransformAction(m_CaseID, m_NodeID, mts3);
	//		MiningStoredData msd3 = action3.transform(msd2);
	//		aOutputBIData.addTransformActionHistory(action3);
	//		System.out.println(msd3);
		
		
			/* Set Output Mining Data */
		    aOutputBIData.setMiningStoredData(msd2);
		
			if (aTargetAttrName!=null){
				MiningAttribute aTargetAttribute = (MiningAttribute) aOutputBIData.getMetaData().getMiningAttribute(aTargetAttrName);
				aOutputBIData.setTargetAttribute(aTargetAttribute);
			}else{
			    aOutputBIData.copyTargetAttribute(aInputBIData.getTargetAttribute());
			}	
			
		}else{
		    MiningStoredData msd4 = new MiningStoredData();
	        (new CopyMiningStream()).transform(aInputBIData.getMiningStoredData(), msd4);
//			MiningStoredData msd4 = action4.transform(aInputBIData.getMiningStoredData());
			
			aOutputBIData.setMiningStoredData(msd4);
		    aOutputBIData.copyTargetAttribute(aInputBIData.getTargetAttribute());
		}
		
		m_OutputBIObject.setBIData(aOutputBIData);	
		
		/* set run time parameter value to the node object (It needs to be stored in the BIML) */
		//a_OperatorNode.setParameterValue("Temporary data", aOutputBIData.getTempBIDataPath());				
		
		/* write temp data */
		//aOutputBIData.writeTempBIData();
		
	}
	
	@SuppressWarnings("unused")
	private int getDataTypeVal(String a_Type, String a_DataType){
	    String [] dataType;
	    int [] dataTypeVal;
	    
	    if(a_Type.equals(DataSetAttributesOperatorProperty.CATEGORICAL)){
	       dataType = CATEGORICAL_DATA_TYPE;
	       dataTypeVal = CATEGORICAL_DATA_TYPE_VAL;
	    }else{
	        dataType = NUMERIC_DATA_TYPE;
		    dataTypeVal = NUMERIC_DATA_TYPE_VAL;
	    }
	    
	    for(int i =0; i<dataType.length; i++){
	        if(a_DataType.equals(dataType[i]))
	            return dataTypeVal[i];
	    }
	    
	    return -1;
	}

	@SuppressWarnings("unused")
	private String getDataType(String a_Type, int a_DataTypeVal){
	    String [] dataType;
	    int [] dataTypeVal;
	    
	    if(a_Type.equals(DataSetAttributesOperatorProperty.CATEGORICAL)){
	       dataType = CATEGORICAL_DATA_TYPE;
	       dataTypeVal = CATEGORICAL_DATA_TYPE_VAL;
	    }else{
	        dataType = NUMERIC_DATA_TYPE;
		    dataTypeVal = NUMERIC_DATA_TYPE_VAL;
	    }
	    
	    for(int i =0; i<dataType.length; i++){
	        if(a_DataTypeVal == dataTypeVal[i])
	            return dataType[i];
	    }
	    
	    return "";
	}
	
	
	@SuppressWarnings({ "unchecked", "unchecked" })
	private boolean validateParameters(MiningDataSpecification a_MetaData, IOperatorNode a_Node)
		
	{
	  
	    m_Parameters = new Hashtable();
	    String message = "";
	    String [] param;
	    boolean valid = false;
	    MiningAttribute[] miningAttributes = a_MetaData.getAttributesArray();
		m_AttrNames = new String[miningAttributes.length];
	
		String value = null;
		for (int i=0; i<miningAttributes.length; i++)
		{
		    valid = false;
		    param = new String[5];
		    m_AttrNames[i] = miningAttributes[i].getName();			
			
			value = (String) a_Node.getParameterValue(m_AttrNames[i]); 
			if (value!=null){
			    param = value.split(",");
			    if(param.length == 5){
				    if((param[0].equalsIgnoreCase(DataSetAttributesOperatorProperty.CATEGORICAL) && param[1].equalsIgnoreCase(DataSetAttributesOperatorProperty.STRING))
				            || (param[0].equalsIgnoreCase(DataSetAttributesOperatorProperty.NUMERIC) && param[1].equalsIgnoreCase(DataSetAttributesOperatorProperty.DOUBLE)) ){
				        if(param[2].equalsIgnoreCase(DataSetAttributesOperatorProperty.TARGET) 
				                || param[2].equalsIgnoreCase(DataSetAttributesOperatorProperty.USE)
				                || param[2].equalsIgnoreCase(DataSetAttributesOperatorProperty.NOT_USE)){
				            valid = true;
				        }
				    }
			    }
			   
			}

			if(!valid){
		    	if(!message.equals(""))
		    	    message += ", ";
		    	message += m_AttrNames[i];
		    	
		    	return false;
			    	
			}else {
			    Vector tmp = new Vector();
			    for (int j=0; j<3; j++){
			        tmp.add(param[j]);
			    }
			    m_Parameters.put(m_AttrNames[i], tmp);
			}
		}
		
		return true;
		
//		if(!AllValid){
//		    throw new AppException("Please select target type, target data type, and role for attribute(s): " + message);
//		}
	    
	}
}