missingvaluesoperator.java

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

/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

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


import java.util.Vector;


import com.prudsys.pdm.Core.CategoricalAttribute;
import com.prudsys.pdm.Core.Category;
import com.prudsys.pdm.Core.MiningAttribute;
import com.prudsys.pdm.Core.MiningDataSpecification;
import com.prudsys.pdm.Core.MiningException;
import com.prudsys.pdm.Core.NumericAttribute;
import com.prudsys.pdm.Input.MiningStoredData;
import com.prudsys.pdm.Transform.MiningTransformationFactory;
import com.prudsys.pdm.Transform.MiningTransformationStep;
import com.prudsys.pdm.Transform.OneToOne.ReplaceMissingAttributeValue;

import eti.bi.alphaminer.core.handler.ICaseHandler;
import eti.bi.alphaminer.core.transform.XelopesTransformAction;
import eti.bi.alphaminer.operation.operator.INodeInfo;
import eti.bi.alphaminer.operation.operator.Operator;
import eti.bi.alphaminer.operation.operator.TransformOperator;
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;
import eti.bi.util.ValueValidator;

/**
 * ReplacementOperator is a kind of Operator
 */
public class MissingValuesOperator extends TransformOperator {
    /**
	 * 
	 */
	private static final long serialVersionUID = 1L;

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


	private final static String CATEG = "Categorical";
	private final static String NUM = "Numeric";
	
	/**
	 * Set node id and update operator text of the Missing Values at the same time.
	 * @param a_NodeID ID of the node
	 */
	public void setNodeID(String a_NodeID) {
		setLabel(getDescription() + " [" + a_NodeID + "]");
		super.setNodeID(a_NodeID);
	}
	
	/**
	 * Set node id and update operator text of the Missing Values 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 + "]");		
	}
	
	/* (non-Javadoc)
	 * @see eti.bi.alphaminer.ui.operator.Operator#hasResult()
	 */
	public boolean hasResult() {
	    /* Normally the operator has to check if the output data object and/or the output
   		 * model object are exist by calling m_OutputBIObject.hasResult(int) by passing BIObject.DATA
   		 * and BIObject.MODEL respectively. You may check both existance or either one by simple modifying
   		 * the logic below.  
   		 */
   		if (m_OutputBIObject != null)
   		{
   			return (m_OutputBIObject.hasResult(BIObject.DATA)); //&&
//   					m_OutputBIObject.hasResult(BIObject.MODEL));
   		}else
   		{
   			return false;
   		}
	}

	/* (non-Javadoc)
	 * @see eti.bi.alphaminer.ui.operator.Operator#execute(eti.bi.alphaminer.vo.OperatorNode, java.util.Vector)
	 */
	public void execute(IOperatorNode a_OperatorNode, Vector a_Parents) throws MiningException, AppException, SysException 
	{
		/* 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 */
   		validateParameters(aInputBIData.getMetaData(),a_OperatorNode);
//   		String aTargetAttrName = a_OperatorNode.getParameterValue("target");
		
   		
   		/* Prepare output mining data */
   		BIData aOutputBIData = new BIData(getCaseID(), getNodeID());
   		@SuppressWarnings("unused") BIModel aOutputBIModel = new BIModel(getCaseID(), getNodeID(), IBIModel.TYPE_CLASSIFIER);
   		
   		
   		/* Execute transform */
   		MiningTransformationFactory mtf = new MiningTransformationFactory();
		ReplaceMissingAttributeValue rep = prepareRemoveAttributes(aInputBIData.getMetaData(),a_OperatorNode);
		mtf.addOneToOneMapping(rep);
		MiningTransformationStep mts = mtf.createMiningTransformationStep();
		XelopesTransformAction aTransformAction = new XelopesTransformAction(m_CaseID, m_NodeID, mts);
		MiningStoredData aOutputMiningStoredData = aTransformAction.transform(aInputBIData.getMiningStoredData());
   		
		
   		/* Set Output Mining Data */
		aOutputBIData.setMiningStoredData(aOutputMiningStoredData);
		aOutputBIData.copyTransformActionHistory(aInputBIData.getTransformActionHistory());
		aOutputBIData.addTransformActionHistory(aTransformAction);
//		MiningAttribute aTargetAttribute = (MiningAttribute) aOutputBIData.getMetaData().getMiningAttribute(aTargetAttrName);
//		aOutputBIData.setTargetAttribute(aTargetAttribute);
		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();   		
   	}
		
	
	public ReplaceMissingAttributeValue prepareRemoveAttributes(MiningDataSpecification a_MetaData, IOperatorNode a_Node) throws MiningException
	{
   	    ReplaceMissingAttributeValue rep = new ReplaceMissingAttributeValue();
		
   	    String sourceName = (String) a_Node.getParameterValue("target");
	    String repValue = (String) a_Node.getParameterValue("repValue"); 
	   	    
	    MiningAttribute mAtt = a_MetaData.getMiningAttribute(sourceName);
	    
	    rep.setSourceName(sourceName);
	    rep.setTargetName(sourceName);
	    rep.setRemoveSourceAttribute(true);
	     
	    if (mAtt instanceof CategoricalAttribute) {
	        Category cat = new Category(repValue);
	        double index = ((CategoricalAttribute) mAtt).getKey(cat);
	        if (!Double.isNaN(index)){
	            rep.setRepCateg(cat);
	        }else {
//	            ((CategoricalAttribute) mAtt).addCategory(cat);
	            rep.setRepCateg(cat);
	        }
          
	    }else {
	        rep.setRepValue( Double.parseDouble(repValue));
	    }
   	    
	    
		return rep;
	}
	
	
	private void validateParameters (MiningDataSpecification a_MetaData, IOperatorNode a_Node) throws AppException{
	   
   	    String sourceName = (String) a_Node.getParameterValue("target");
	    String repValue = (String) a_Node.getParameterValue("repValue"); 
	    String targetType = (String) a_Node.getParameterValue("targetType");
	    
	    boolean valid = true;
	    String message = "";
	    
	    if(sourceName == null){
	        message += Resource.srcStr("AttributeMessage");
	        valid = false;
	        throw new AppException (message);	 
	    }	    
	   
	        
	    if(valid){
	        MiningAttribute mAtt = a_MetaData.getMiningAttribute(sourceName);
	        if (mAtt == null) {
                message += Resource.srcStr("AttributeMessage");
                throw new AppException (message);	 
	        }
	        else{
		        if(mAtt instanceof NumericAttribute){
		            if(targetType ==null
		                      || !targetType.equals(NUM)){
			                message += Resource.srcStr("AttributeMessage");
				            throw new AppException (message);	
			            }
		            
		            if(repValue ==null 
		                    || !ValueValidator.isDouble(repValue)){
		                message += "Replacement value should be a double\n";
			            throw new AppException (message);	 
		            }
		        
		        }else if((mAtt instanceof CategoricalAttribute)){
		            if(targetType ==null
	                        || !targetType.equals(CATEG)){
		                message += Resource.srcStr("AttributeMessage");
			            throw new AppException (message);	 
		            }
		            
		            if(repValue ==null 
	                        || repValue.trim().equals("")){
		                message += "Replacement value should not be empty\n";
			            throw new AppException (message);	 
		            }	           
		            
		        }
            }
	    }
	    
//	    if(!message.equals(""))
//	        throw new AppException (message);	 
	    }
	
}