applicationinputspecification.java

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

                                inputAttribute[i].setUsageType( new AttributeUsage( AttributeUsage.ACTIVE ) );
                            }
                            else
                            {
                                inputAttribute[i].setUsageType( new AttributeUsage( AttributeUsage.SUPPLEMENTARY ) );
                            }
                            targetApplicationAttribute = null;
                        }
                    }
                    else
                    {
                        // Customer sequential settings:
                        if( settings instanceof CustomerSequentialSettings )
                        {
                            int numberOfInputAttributes = inputAttribute.length;
                            for( int i = 0; i < numberOfInputAttributes; i++ )
                            {
                                if( ( inputAttribute[i].getName() ).equalsIgnoreCase( ((CustomerSequentialSettings)settings).getItemId().getName() )
                                    ||
                                    ( inputAttribute[i].getName() ).equalsIgnoreCase( ((CustomerSequentialSettings)settings).getCustomerId().getName() )
                                    ||
                                    ( inputAttribute[i].getName() ).equalsIgnoreCase( ((CustomerSequentialSettings)settings).getTransactionPosition().getName() ))
                                {
                                    inputAttribute[i].setUsageType( new AttributeUsage( AttributeUsage.ACTIVE ) );
                                }
                                else
                                {
                                    inputAttribute[i].setUsageType( new AttributeUsage( AttributeUsage.SUPPLEMENTARY ) );
                                }
                                targetApplicationAttribute = null;
                            }
                        }
                    }
                }
            }
        }
    }

    // -----------------------------------------------------------------------
    //  Inner transformation methods
    // -----------------------------------------------------------------------
    /**
     * Creates inner transformation from application input specification.
     * For this purpose, a mining transformation activity is created.
     * It may consist of three steps:
     * 1. Outlier treatment, if one of the attributes is different from "asIs",
     * 2. Missing value replacement, if one of the attributes is different from "asIs",
     * 3. Remove mining attributes, if input specification does not contain all attributes of meta data
     *
     * If no transformation step was created, null is returned.
     *
     * @param metaData meta data
     * @return mining transformation activity as inner transformation if required, otherwise null
     */
    public MiningTransformationActivity createInnerTrafoFromInputSpec(MiningDataSpecification metaData) {

      MiningTransformationActivity innerTrafo = null;

      // Get outlier treatment and missing value replacements:
      MiningTransformationActivity mta = new MiningTransformationActivity();
      MiningTransformationFactory mtf  = new MiningTransformationFactory();
      ApplicationAttribute[] appAtt    = inputAttribute;

      // Get outlier treatment:
      boolean treatout = false;
      for (int i = 0; i < appAtt.length; i++) {
         String outliers = appAtt[i].getOutliers();
         // No outlier treatment:
         if ( outliers == null || outliers.equals("asIs") )
           continue;

         // Special outlier treatment for this attribute:
         treatout = true;
         MiningAttribute mAtt = metaData.getMiningAttribute( appAtt[i].getName() );
         TreatOutlierAttributeValue tro = new TreatOutlierAttributeValue();
         tro.setSourceName( appAtt[i].getName() );
         tro.setOutliers( outliers );
         tro.setAssessmentAttribute( mAtt );

         mtf.addOneToOneMapping(tro);
      };
      if (treatout)
        mta.addTransformationStep( mtf.createMiningTransformationStep());

      // Get missing value replacements:
      mtf.reset();
      boolean replace = false;
      for (int i = 0; i < appAtt.length; i++) {
         // No missing value replacement:
         if ( appAtt[i].getMissingValueTreatment() == null ||
              appAtt[i].getMissingValueTreatment().equals("asIs") )
           continue;
         // Replace missing value for this attribute:
         replace = true;
         MiningAttribute mAtt = metaData.getMiningAttribute( appAtt[i].getName() );
         ReplaceMissingAttributeValue rep = new ReplaceMissingAttributeValue();
         rep.setSourceName( appAtt[i].getName() );
         String value = appAtt[i].getMissingValueReplacement();
         if (mAtt instanceof CategoricalAttribute) {
           Category cat = new Category(value);
           double key = ( (CategoricalAttribute) mAtt).getKey(cat);
           rep.setRepValue(key);
           rep.setRepCateg(cat);
         }
         else {
           double key = Double.parseDouble( value );
           rep.setRepValue(key);
         };

         mtf.addOneToOneMapping(rep);
      };
      if (replace)
        mta.addTransformationStep( mtf.createMiningTransformationStep() );

      // Remove attributes not used in mining schema:
      mtf.reset();
      boolean remove = false;
      Vector remNames = new Vector();
      for (int i = 0; i < metaData.getAttributesNumber(); i++) {
        boolean found = false;
        String mdName = metaData.getMiningAttribute(i).getName();
        for (int j = 0; j < appAtt.length; j++) {
          if ( appAtt[j].getName().equals(mdName) &&
               appAtt[j].getUsageType().getType() != AttributeUsage.SUPPLEMENTARY )
            found = true;
        };
        if (!found) {
          remNames.addElement(mdName);
          remove = true;
        };
      };
      RemoveAttributes remAtt = new RemoveAttributes();
      String[] sourceNames = new String[ metaData.getAttributesNumber() ];
      for (int i = 0; i < metaData.getAttributesNumber(); i++)
        sourceNames[i] = metaData.getMiningAttribute(i).getName();
      remAtt.setSourceName(sourceNames);
      remAtt.setRemoveAttributeNames(remNames);
      mtf.addMultipleToMultipleMapping(remAtt);
      if (remove)
        mta.addTransformationStep( mtf.createMiningTransformationStep() );

      // Create inner transformation, if outliers, missing values, or remove attributes:
      if (treatout || replace || remove)
        innerTrafo = mta;

      return innerTrafo;
    }

    /**
     * Create transformation step which removes all supplementary
     * attributes from meta data.
     *
     * @return transformation step removing all supplementary attributes, otherwise null
     */
    public MiningTransformationStep createRemoveTrafoFromInputSpec() {

      MiningTransformationStep removeTrafo = null;

      MiningTransformationFactory mtf = new MiningTransformationFactory();
      RemoveAttributes ra = new RemoveAttributes();
      Vector remVec = new Vector();
      for (int i = 0; i < inputAttribute.length; i++) {
        if ( inputAttribute[i].getUsageType().getType() == AttributeUsage.SUPPLEMENTARY )
          remVec.addElement( inputAttribute[i].getName() );
      };
      if ( remVec.size() > 0 ) {
        ra.setRemoveAttributeNames(remVec);
        mtf.addMultipleToMultipleMapping(ra);
        removeTrafo = mtf.createMiningTransformationStep();
      }

      return removeTrafo;
    }

    /**
     * Sets the outlier treatment and missing value replacement of
     * the application input specification from corresponding tranformations.
     * Counterpart to method createInnerTrafoFromInputSpec.
     *
     * @param metaData meta data
     * @param tro transformation of outlier treatment, null if not used
     * @param rep transformation of missing value replacement, null if not used
     */
    public void setInputSpecFromInnerTrafo(MiningDataSpecification metaData, TreatOutlierValueStream tro, ReplaceMissingValueStream rep) {

      ApplicationAttribute[] appAtt = inputAttribute;
      double[] lowVal  = null;
      if (tro != null) lowVal = tro.getLowValues();
      double[] highVal = null;
      if (tro != null) highVal = tro.getHighValues();
      double[] repVal  = null;
      if (rep != null) repVal = rep.getRepValues();

      // Loop over all application attributes:
      for (int i = 0; i < appAtt.length; i++) {
        // Numeric application attribute:
        if (appAtt[i].getAttributeType().getType() == AttributeType.NUMERICAL) {

          // Treatment of outliers to application attribute:
          if (tro != null) {
            appAtt[i].setOutliers( tro.getNumOutliers() );
            if (appAtt[i].getOutliers().equals(
               ApplicationAttribute.OUTLIER_TREATMENT_METHOD_asExtremeValues) ){
              appAtt[i].setLowValue( String.valueOf( lowVal[i] )  );
              appAtt[i].setHighValue( String.valueOf( highVal[i] ) );
            };
          };

          // Missing values to application attribute:
          if (rep != null) {
            appAtt[i].setMissingValueTreatment(
              ApplicationAttribute.MISSING_VALUE_TREATMENT_METHOD_asMean);
            appAtt[i].setMissingValueReplacement( String.valueOf(repVal[i]) );
          };
        };

        // Categorical application attribute:
        if (appAtt[i].getAttributeType().getType() == AttributeType.CATEGORICAL) {

          // Treatment of outliers to application attribute:
          if (tro != null) {
            appAtt[i].setOutliers( tro.getCatOutliers() );
          };

          // Missing values to application attribute:
          if (rep != null) {
            appAtt[i].setMissingValueTreatment(
               ApplicationAttribute.MISSING_VALUE_TREATMENT_METHOD_asMode);
            CategoricalAttribute ca = ((CategoricalAttribute) metaData.getMiningAttribute(i));
            Category cat = ca.getCategory( repVal[i] );
            String reps = "";
            if ( cat != null)
              reps = cat.getDisplayValue();
            else {
              double key = ca.getKey( new Category(reps) );
              if ( Category.isMissingValue(key) ) {
                ca.addCategory( new Category(reps) );
              }
            }
            appAtt[i].setMissingValueReplacement( reps );
          };
        };
      };
    }

    // -----------------------------------------------------------------------
    //  Methods of PMML handling
    // -----------------------------------------------------------------------
    /**
     * Creates PMML object of application input specification.
     * This is the PMML element MiningSchema.
     *
     * @return PMML object MiningSchema
     * @throws MiningException if can't create pmml representation for input specification
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.MiningSchema
     */
    public Object createPmmlObject() throws MiningException
    {
        MiningSchema miningSchema   = new MiningSchema();
        int numberOfInputAttributes = inputAttribute.length;
        MiningField[] miningField   = new MiningField[numberOfInputAttributes];
        for( int i = 0; i < numberOfInputAttributes; i++ )
        {
            if (inputAttribute[i].getInputSpec() == null) inputAttribute[i].setInputSpec(this);
            miningField[i] = (MiningField) inputAttribute[i].createPmmlObject();
        }
        miningSchema.setMiningField( miningField );

        return miningSchema;
    }

    /**
     * Reads application input specification from corresponding
     * PMML obejct MiningSchema.
     *
     * @param pmml PMML element MiningSchema
     * @throws MiningException if can't restore input specification from PMML
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.MiningSchema
     */
    public void parsePmmlObject( Object pmml ) throws MiningException
    {
        MiningSchema miningSchema   = (MiningSchema) pmml;
        int numberOfInputAttributes = miningSchema.getMiningFieldCount();
        inputAttribute              = new ApplicationAttribute[numberOfInputAttributes];
        for (int i = 0; i < numberOfInputAttributes; i++)
        {
            MiningField field = miningSchema.getMiningField( i );
            inputAttribute[i] = new ApplicationAttribute();
            inputAttribute[i].setInputSpec( this );
            inputAttribute[i].parsePmmlObject(field);
        }
    }

    // -----------------------------------------------------------------------
    //  java.lang.Object methods
    // -----------------------------------------------------------------------
    /**
     * Returns application input specification as string.
     *
     * @return attribute input specification as string
     */
    public String toString()
    {
        String s = "";
        if ( inputAttribute != null ) {
          for (int i = 0; i < inputAttribute.length; i++) {
            s = s + inputAttribute[i].toString();
            if (i < inputAttribute.length - 1)
              s = s + "\n";
          };
        };

        return s;
    }
}