miningtransformationstep.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.
 */

 /**
  * Title: XELOPES Data Mining Library
  * Description: The XELOPES library is an open platform-independent and data-source-independent library for Embedded Data Mining.
  * Copyright: Copyright (c) 2002 Prudential Systems Software GmbH
  * Company: ZSoft (www.zsoft.ru), Prudsys (www.prudsys.com)
  * @author Michael Thess
  * @author Thilo Maier
  * @version 1.0
  */

package com.prudsys.pdm.Transform;

import java.util.Vector;

import com.prudsys.pdm.Core.MiningAttribute;
import com.prudsys.pdm.Core.MiningDataSpecification;
import com.prudsys.pdm.Core.MiningException;
import com.prudsys.pdm.Cwm.Transformation.TransformationStep;
import com.prudsys.pdm.Cwm.Transformation.TransformationTask;
import com.prudsys.pdm.Input.MiningInputStream;
import com.prudsys.pdm.Input.MiningVector;
import com.prudsys.pdm.Utils.IntVector;

/**
 * Contains a number of transformations where the order of their application
 * has no impact on the result.
 */
public class MiningTransformationStep extends TransformationStep implements MiningTransformer, MiningStreamTransformer
{
  // -----------------------------------------------------------------------
  //  Variables declarations
  // -----------------------------------------------------------------------
  /** Pretransformed meta data. */
  private MiningDataSpecification pretransMetaData = new MiningDataSpecification();

  /** Transformed meta data. */
  private MiningDataSpecification transMetaData = new MiningDataSpecification();

  /** Array of transformation values coordinate maps. */
  private IntVector[] cmaps = null;

  // -----------------------------------------------------------------------
  //  Constructor
  // -----------------------------------------------------------------------
  /**
   * Empty constructor.
   */
  public MiningTransformationStep()
  {
  }

  // -----------------------------------------------------------------------
  //  Getter and setter methods
  // -----------------------------------------------------------------------
  /**
   * Sets transformation task. Usually this will be a mining transformation
   * task.
   *
   * @param task new transformation task
   */
  public void setTransformationTask(TransformationTask task) {

    this.task = task;

    task.step    = new TransformationStep[1];
    task.step[0] = this;
  }

  /**
   * Returns transformation task. Usually this will be a mining transformation
   * task.
   *
   * @return transformation task
   */
  public TransformationTask getTransformationTask() {

    return task;
  }

  // -----------------------------------------------------------------------
  //  Transformation methods
  // -----------------------------------------------------------------------
  /**
   * Transforms mining vector. Uses same method of MultipleToMultipleMapping.
   *
   * Notice that this method can also be applied to a mining vector without
   * own meta data. In this case the last meta data transformation is used
   * as transformation ressource. Such last meta data transformation could have
   * been done either explicitly, applying transform to some meta data, or
   * implicitely, when a mining vactor with meta data was transformed. If
   * none of both cases has ever happened, for the mining vector (without
   * meta data) an exception is thrown.
   *
   * @param vector mining vector to transform
   * @return transformed mining vector, with meta data
   * @exception MiningException cannot transform mining vector
   */
  public MiningVector transform( MiningVector vector ) throws MiningException {

    // Transform meta data:
    MiningDataSpecification vecMetaData = vector.getMetaData();
    if (vecMetaData != null) {
      if (vecMetaData != pretransMetaData)
        transMetaData = transform(vecMetaData); // Caching
    }
    else {
      if (transMetaData == null)
        throw new MiningException("No meta data ressource for trafo available");
    }

    // Transform mining vector:
    double[] values = new double[transMetaData.getAttributesNumber()];

    int imap = 0;
    MiningTransformationTask mtt = (MiningTransformationTask) task;
    for (int i = 0; i < mtt.transformation.length; i++) {
      MiningTransformation mt = (MiningTransformation) mtt.transformation[i];
      if (! (mt instanceof MiningTransformationMap))
        continue;
      MiningTransformationMap mtm = (MiningTransformationMap) mt;
      for (int j = 0; j < mtm.miningClassifierMap.length; j++) {
        MiningVector mv = mtm.miningClassifierMap[j].transform( vector );
        IntVector cmap  = cmaps[imap];
        for (int k = 0; k < cmap.size(); k++) {
          int ind     = cmap.IntegerAt(k);
          if (ind > -1) values[ind] = mv.getValue(k);
        };
        imap = imap + 1;
      };
    };

    MiningVector minVec = new MiningVector(values);
    minVec.setMetaData(transMetaData);

    return minVec;
  }

  /**
   * Transforms meta data. Uses same method of MiningClassifierMap.
   *
   * @param metaData meta data to transform
   * @return transformed meta data
   * @exception MiningException cannot transform meta data
   */
  public MiningDataSpecification transform( MiningDataSpecification metaData ) throws MiningException {

    // Caching:
    pretransMetaData = metaData;

    // Initializations:
    MiningDataSpecification tMDS = new MiningDataSpecification();
    Vector transNames            = new Vector();
    Vector removeAtt             = new Vector();
    int nmap                     = 0;
    Vector mdsAtts               = new Vector();

    // Transform meta data:
    MiningTransformationTask mtt = (MiningTransformationTask) task;
    for (int i = 0; i < mtt.transformation.length; i++) {
      MiningTransformation mt = (MiningTransformation) mtt.transformation[i];
      if (! (mt instanceof MiningTransformationMap))
        continue;
      MiningTransformationMap mtm = (MiningTransformationMap) mt;
      for (int j = 0; j < mtm.miningClassifierMap.length; j++) {
        // Transformation of meta data by classifier map:
        MiningDataSpecification mds = mtm.miningClassifierMap[j].transform( metaData );

        // Add to mds attribute array:
        String[] attNames = new String[ mds.getAttributesNumber() ];
        for (int k = 0; k < mds.getAttributesNumber(); k++)
          attNames[k] = mds.getMiningAttribute(k).getName();
        mdsAtts.addElement(attNames);

        // Add to transformed attribute list:
        for (int k = 0; k < mds.getAttributesNumber(); k++) {
          MiningAttribute mAtt = mds.getMiningAttribute(k);
          if (transNames.indexOf(mAtt.getName()) == -1) {
            tMDS.addMiningAttribute(mAtt);
            transNames.addElement(mAtt.getName());
          };
        };

        // Find attributes that have been removed:
        for (int k = 0; k < metaData.getAttributesNumber(); k++) {
          String attName = metaData.getMiningAttribute(k).getName();
          boolean found  = false;
          for (int l = 0; l < mds.getAttributesNumber(); l++)
            if ( mds.getMiningAttribute(l).getName().equals(attName) )
              found = true;
          if (!found)
            removeAtt.addElement(attName);
         };
         nmap = nmap + 1;
      };
    };

    // Remove all removeable attributes:
    for (int i = 0; i < removeAtt.size(); i++) {
      String attName = (String) removeAtt.elementAt(i);
      int ind = transNames.indexOf(attName);
      if (ind > -1)
        transNames.remove(ind);
    };

    // Create transformed meta data:
    transMetaData = new MiningDataSpecification();
    for (int i = 0; i < transNames.size(); i++) {
      String attName = (String) transNames.elementAt(i);
      transMetaData.addMiningAttribute( tMDS.getMiningAttribute(attName) );
    };
    transMetaData.setRelationName( "transformed_" + metaData.getRelationName()  );
    transMetaData.setTransformed( metaData.isTransformed() );
    transMetaData.setPretransformedMetaData( metaData.getPretransformedMetaData() );
    transMetaData.setMiningTransformationActivity( metaData.getMiningTransformationActivity() );

    // Create coordinate mapping:
    cmaps    = new IntVector[nmap];
    int imap = 0;
    for (int i = 0; i < mtt.transformation.length; i++) {
      MiningTransformation mt = (MiningTransformation) mtt.transformation[i];
      if (! (mt instanceof MiningTransformationMap))
        continue;
      MiningTransformationMap mtm = (MiningTransformationMap) mt;
      for (int j = 0; j < mtm.miningClassifierMap.length; j++) {
        IntVector cmap              = new IntVector();
        String[] attNames = (String[]) mdsAtts.elementAt(imap);
        for (int k = 0; k < attNames.length; k++) {
          int ind = transNames.indexOf( attNames[k] );
          cmap.addElement(ind);
        };
        cmaps[imap] = cmap;
        imap        = imap + 1;
      };
    };

    return transMetaData;
  }

  /**
   * Transforms mining input stream into another one. Realized by calling
   * the transform methods of this class for all mining vectors. The
   * targetStream must contain an updatable mining stream.
   *
   * @param sourceStream mining stream used as source of transformation
   * @param targetStream mining strem used as target of transformation
   * @return number of vectors of transformation
   * @exception MiningException cannot transform mining input stream
   */
  public int transform( MiningInputStream sourceStream, MiningInputStream targetStream )
    throws MiningException {

    // Transform metadata:
    MiningDataSpecification metaDataSource = sourceStream.getMetaData();
    targetStream.updateSetMetaData( transform(metaDataSource) );

    // Transform stream:
    int nVec = 0;
    sourceStream.reset();
    targetStream.updateRemoveAllVectors();
    while (sourceStream.next()) {
      MiningVector targetVec = transform( sourceStream.read() );
      targetStream.updateAppendVector(targetVec);
      nVec = nVec + 1;
    };

    return nVec;
  }

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

    String res = "--Mining transformation step. Contains task: " + "\n" +
                 task.toString() + "\n";

    return res;
  }

}