miningtransformationactivity.java

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

          continue;
        MiningTransformationMap mtm = (MiningTransformationMap) mt;
        for (int k = 0; k < mtm.miningClassifierMap.length; k++) {
          MultipleToMultipleMapping mcm = mtm.miningClassifierMap[k];
          DerivedField[] fields = (DerivedField[]) mcm.createPmmlObjects();
          for (int l = 0; l < fields.length; l++)
            dictionary.addDerivedField(fields[l]);
        };
      };
    };

    return dictionary;
  }

  /**
   * Creates this object from TransformationDictionary.
   *
   * @param pmml TransformationDictionary element
   * @exception MiningException cannot parse PMML object
   */
  public void parsePmmlObject(Object pmml) throws MiningException
  {
    // Transformation dictionary:
    TransformationDictionary dictionary = (TransformationDictionary) pmml;

    // Determine all transformation steps required:
    DerivedField[] fields = dictionary.getDerivedField();
    int nTrafo            = fields.length;
    int[] steps           = findTransformationSteps(fields);

    int nSteps = 0;
    for (int i = 0; i < nTrafo; i++)
      if (steps[i] > nSteps) nSteps = steps[i];
    nSteps = nSteps + 1;
    int[] trafosPerStep = new int[nSteps];
    for (int i = 0; i < nTrafo; i++) {
      int step = steps[i];  // step where the trafo belongs to
      trafosPerStep[step] = trafosPerStep[step] + 1;
    };

    // Parse all transformation steps:
    transformationSteps = new Vector();
    for (int i = 0; i < nSteps; i++) {

      // Mining classifier map:
      MultipleToMultipleMapping[] mcm = new MultipleToMultipleMapping[1];
      mcm[0] = new MultipleToMultipleMapping();
      // Parse derived fields assigned to this step:
      DerivedField[] stepFields = new DerivedField[ trafosPerStep[i] ];
      int ind = 0;
      for (int j = 0; j < nTrafo; j++)
        if (steps[j] == i) {
          stepFields[ind] = fields[j];
          ind = ind + 1;
        };
      mcm[0].parsePmmlObjects(stepFields);

      // Mining transformation map:
      MiningTransformationMap[] mtm = new MiningTransformationMap[1];
      mtm[0] = new MiningTransformationMap();
      mtm[0].setMiningClassifierMap(mcm);

      // Mining transformation task:
      MiningTransformationTask mtt = new MiningTransformationTask();
      mtt.setMiningTransformation(mtm);

      // Mining transformation step:
      MiningTransformationStep mts = new MiningTransformationStep();
      mts.setTransformationTask(mtt);

      // Add to mining transformation activity:
      addTransformationStep(mts);
    };
  }

  /**
   * Determines all transformation steps from the derived fields
   * and returns the assignment from the derived fields to the
   * transformation step.
   *
   * @param fields all tranformations
   * @return number of transformation step the derived field is assigned to
   */
  private int[] findTransformationSteps(DerivedField[] fields) {

    int nTrafo = fields.length;
    String[][] stPairs = findSourceTargetTrafoPairs(fields);

    for (int i = 0; i < nTrafo; i++)
      System.out.println("sourceName = " + stPairs[i][0] + " " +
                         "targetName = " + stPairs[i][1]);

    int[] steps = findTrafoStepsInSourceTargetPairs(nTrafo, stPairs);
    int nSteps = 0;
    for (int i = 0; i < nTrafo; i++)
      if (steps[i] > nSteps) nSteps = steps[i];
    nSteps = nSteps + 1;
    System.out.println("#steps: " + nSteps);
    for (int i = 0; i < nTrafo; i++)
      System.out.println("step ass = " + steps[i]);

    return steps;
  }

  /**
   * Determines the source and target pairs for all transformations.
   *
   * @param fields all tranformations
   * @return source / target pairs for all transformations
   */
  private String[][] findSourceTargetTrafoPairs(DerivedField[] fields) {

    int nTrafo         = fields.length;
    String[][] stPairs = new String[nTrafo][2];
    for (int i = 0; i < fields.length; i++) {
      // Get source name:
      String sourceName = "";
      if ( fields[i].getFieldRef() != null )
        sourceName = fields[i].getFieldRef().getField();
      else if ( fields[i].getNormContinuous() != null )
        sourceName = fields[i].getNormContinuous().getField();
      else if ( fields[i].getNormDiscrete() != null )
        sourceName = fields[i].getNormDiscrete().getField();
      else if ( fields[i].getDiscretize() != null )
        sourceName = fields[i].getDiscretize().getField();
      else if ( fields[i].getNumerization() != null )
        sourceName = fields[i].getNumerization().getField();
      else if ( fields[i].getCategorization() != null )
        sourceName = fields[i].getCategorization().getField();
      else if ( fields[i].getMapValues() != null ) {
        FieldColumnPair[] fcp = fields[i].getMapValues().getFieldColumnPair();
        sourceName = fcp[0].getField();
      }
      else if ( fields[i].getMapValuesNum() != null ){
        FieldColumnPair[] fcp =fields[i].getMapValuesNum().getFieldColumnPair();
        sourceName = fcp[0].getField();
      }
      else if ( fields[i].getExponential() != null )
        sourceName = fields[i].getExponential().getField();
      else if ( fields[i].getLogarithmic() != null )
        sourceName = fields[i].getLogarithmic().getField();
      else if ( fields[i].getReciprocal() != null )
        sourceName = fields[i].getReciprocal().getField();
      else if ( fields[i].getRoot() != null )
        sourceName = fields[i].getRoot().getField();
      else if ( fields[i].getSquare() != null )
        sourceName = fields[i].getSquare().getField();
      else if ( fields[i].getCreateVirtualAttribute() != null )
        sourceName = fields[i].getCreateVirtualAttribute().getField();
      else
        continue;
      stPairs[i][0]     = sourceName;

      // Get target name:
      String targetName = fields[i].getName();
      stPairs[i][1]     = targetName;
    };

    return stPairs;
  }

  /**
   * Determines the transformation steps using the source-target pairs
   * of all transformations.
   *
   * @param nTrafo number of transformation
   * @param stPairs source-target attributes of all transformations
   * @return numbers of transformation steps for all transformations
   */
  private int[] findTrafoStepsInSourceTargetPairs(int nTrafo, String[][] stPairs) {

    int[] steps = new int[nTrafo];

    // Find all initial attributes, i.e. all attributes which are no target ones:
    Vector attributes = new Vector();
    for (int i = 0; i < nTrafo; i++) {
      String att = stPairs[i][0];
      if ( attributes.indexOf(att) == -1 ) attributes.addElement(att);
    };
    Vector attLayer = new Vector();
    for (int i = 0; i < attributes.size(); i++) {
      String att = (String) attributes.elementAt(i);
      boolean sourceOnly = true;
      for (int j = 0; j < nTrafo; j++)
        if ( stPairs[j][1].equals(att) ) {
          sourceOnly = false;
          break;
        };
      if (sourceOnly) attLayer.addElement(att);
    };

    // Recursively assign transformations to steps:
    for (int i = 0; i < nTrafo; i++)
      steps[i] = -1;
    int iStep = 0;
    while (true) {
      // Asssign trafos with attributes of current layer as source:
      Vector attLayer2 = new Vector();
      for (int i = 0; i < nTrafo; i++) {
        if (steps[i] > -1) continue;
        String sourceName = stPairs[i][0];
        if ( attLayer.indexOf(sourceName) > -1) {
          steps[i]          = iStep;
          String targetName = stPairs[i][1];
          attLayer2.addElement(targetName);
        };
      };

      // Check if new step required:
      boolean allAssigned = true;
      for (int i = 0; i < steps.length; i++)
        if (steps[i] == -1) allAssigned = false;
      if (allAssigned)
        break;

      // Find attributes of next layer:
      attLayer.removeAllElements();
      for (int i = 0; i < attLayer2.size(); i++)
        attLayer.addElement( attLayer2.elementAt(i) );
      iStep = iStep + 1;
    };

    return steps;
  }

  /**
   * Returns string representation of mining transformation activity.
   *
   * @return mining transformation activity string representation
   */
  public String toString() {

    String res = "Mining transformation activity. Consists of " +
                 String.valueOf( getNumberOfTransformationSteps() ) +
                 " steps: " + "\n";
    for (int i = 0; i < getNumberOfTransformationSteps(); i++) {
      res = res + "Step " + String.valueOf(i) + ":" + "\n" +
            getTransformationStepAt(i).toString();
      if (i < getNumberOfTransformationSteps() - 1)
        res = res + "\n";
    };

    return res;
  }
}