wekacoreadapter.java

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

    // Get addElement method:
    Class[] methodArgumentTypes = { Object.class };
    Method classMethod = wekaFastVectorClass.getMethod("addElement", methodArgumentTypes);

    // Get meta data of mining input stream:
    MiningDataSpecification metaData = mis.getMetaData(); 
    
    // Copy attributes to fast vector:
    for (int i = 0; i < metaData.getAttributesNumber() ; i++) {
      Object[] newValue = { PDMAttribute2WekaAttribute( metaData.getMiningAttribute(i) ) };
      classMethod.invoke(fastVector, newValue);
    };

    // Weka's instance class:
    Class wekaInstClass = Class.forName("weka.core.Instances");

    // Get constructor for instance:
    Class[] constructorArgumentTypes = { String.class, wekaFastVectorClass, int.class };
    Constructor classConstructor     = wekaInstClass.getConstructor(
                                         constructorArgumentTypes);

    // Set constructor argument number of attributes:
    Object[] constructorArgs         = { metaData.getRelationName(), fastVector,
                                         new Integer(10) };

    // Create Weka Instances:
    wekaInstances = classConstructor.newInstance(constructorArgs);

    // Get add method:
    Class[] methodArgTypes = { Class.forName("weka.core.Instance") };
    classMethod = wekaInstClass.getMethod("add", methodArgTypes);

    // Add instance's to instances:
    while ( mis.next() ) {
      Object[] instance = { PDMMiningVector2WekaInstance( mis.read(), wekaInstances ) };
      classMethod.invoke(wekaInstances, instance);
    };

    return wekaInstances;
  }

  //<<17/03/2005, Frank J. Xu
  //Simplified version of  PDMMiningInputStream2WekaInstances(....)
  /**
   * Creates Weka Instances from MiningInputStream.
   *
   * @param mis mining input stream to be converted
   * @return Weka instances
   * @exception Exception cannot create Weka instances
   */
  public static Object PDMMiningInputStream2WekaInstances_Simple(MiningInputStream mis)
    throws Exception {

    // New weka instances:
    Object wekaInstances = null;

    // Weka's fast vector class:
    Class wekaFastVectorClass = Class.forName("weka.core.FastVector");

    // Create fast vector object:
    Object fastVector  = wekaFastVectorClass.newInstance();

    // Get addElement method:
    Class[] methodArgumentTypes = { Object.class };
    Method classMethod = wekaFastVectorClass.getMethod("addElement", methodArgumentTypes);
    
    // Get meta data of mining input stream:
    MiningDataSpecification metaData = mis.getMetaData(); 

    // Copy attributes to fast vector:
    for (int i = 0; i < metaData.getAttributesNumber() ; i++) {
      Object[] newValue = { PDMAttribute2WekaAttribute( metaData.getMiningAttribute(i) ) };
      classMethod.invoke(fastVector, newValue);
    };

    // Weka's instance class:
    Class wekaInstClass = Class.forName("weka.core.Instances");

    // Get constructor for instance:
    Class[] constructorArgumentTypes = { String.class, wekaFastVectorClass, int.class };
    Constructor classConstructor     = wekaInstClass.getConstructor(
                                         constructorArgumentTypes);

    // Set constructor argument number of attributes:
    Object[] constructorArgs         = { metaData.getRelationName(), fastVector,
                                         new Integer(10) };

    // Create Weka Instances:
    wekaInstances = classConstructor.newInstance(constructorArgs);
    
    return wekaInstances;
  }
  //17/03/2005, Frank J. Xu>>
  /**
   * Constructor for tests.
   */
  private WekaCoreAdapter() {

    try {
      // Weka's attribute class:
      Class wekaAttClass = Class.forName("weka.core.Attribute");

      // Create numeric attribute:
      NumericAttribute numAtt = new NumericAttribute( "numAtt" );

      // Transform to weka attribute:
      Object numAttWeka = PDMAttribute2WekaAttribute( numAtt );

      Class parameterTypes = null;
      
      // Display:
      Method classMethod = wekaAttClass.getMethod("toString", parameterTypes);
      String attString   = (String) classMethod.invoke(numAttWeka, parameterTypes);
      System.out.println("Weka numerical attribute: " + attString);

      // Create categorical attribute:
      CategoricalAttribute catAtt = new CategoricalAttribute( "catAtt" );

      Category cat1 = new Category("knife", "knife", new CategoryProperty() );
      Category cat2 = new Category("fork", "fork", new CategoryProperty() );
      Category cat3 = new Category("spoon", new Integer(2), new CategoryProperty() );
      catAtt.addCategory( cat1 );
      catAtt.addCategory( cat2);
      catAtt.addCategory( cat3);

      // Transform to weka attribute:
      Object catAttWeka = PDMAttribute2WekaAttribute( catAtt );

      // Display:
      classMethod = wekaAttClass.getMethod("toString", parameterTypes);
      attString   = (String) classMethod.invoke(catAttWeka, parameterTypes);
      System.out.println("Weka categorical attribute: " + attString);

      // Create mining vector:
      double[] arrVal = {1.0, 3.0, -5};
      MiningVector mv = new MiningVector(  arrVal );

      // Transform to weka instance:
      Object instanceWeka = PDMMiningVector2WekaInstance( mv, null );

      // Display:
      Class wekaInstClass = Class.forName("weka.core.Instance");
      classMethod = wekaInstClass.getMethod("toString", parameterTypes);
      attString   = (String) classMethod.invoke(instanceWeka, parameterTypes);
      System.out.println("Weka instance: " + attString);

      // Mining array for xor problem:
      double[][] mArr = new double[4][3];
      mArr[0][0] = 0;
      mArr[0][1] = 0;
      mArr[0][2] = 0.0;
      mArr[1][0] = 0;
      mArr[1][1] = 1;
      mArr[1][2] = 1.0;
      mArr[2][0] = 1;
      mArr[2][1] = 0;
      mArr[2][2] = 1.0;
      mArr[3][0] = 1;
      mArr[3][1] = 1;
      mArr[3][2] = 0.0;

      // Define attributes for current array:
      NumericAttribute numAtt1 = new NumericAttribute("numAtt1");
      NumericAttribute numAtt2 = new NumericAttribute("numAtt2");
      CategoricalAttribute catAtt1 = new CategoricalAttribute("catAtt");
      cat1 = new Category("zero", "zero", new CategoryProperty());
      cat2 = new Category("one" , "one" , new CategoryProperty());
      catAtt1.addCategory(cat1);
      catAtt1.addCategory(cat2);

      // Define new meta data:
      MiningDataSpecification metaData = new MiningDataSpecification();
      metaData.setRelationName("test matrix");
      metaData.addMiningAttribute(numAtt1);
      metaData.addMiningAttribute(numAtt2);
      metaData.addMiningAttribute(catAtt1);

      // Create new mining array stream with new meta data:
      MiningArrayStream mas = new MiningArrayStream( mArr, metaData );

      // Transform to weka instance:
      Object instancesWeka = PDMMiningInputStream2WekaInstances( mas );

      // Display:
      Class wekaInstancesClass = Class.forName("weka.core.Instances");
      classMethod = wekaInstancesClass.getMethod("toString", parameterTypes);
      attString   = (String) classMethod.invoke(instancesWeka, parameterTypes);
      System.out.println("Weka instances: " + attString);

      // Try on a file. ARFF file ==> mining input stream => ARFF Instances:
      MiningInputStream inputData = new MiningArffStream( "data/arff/labor.arff" );
      Object inst = PDMMiningInputStream2WekaInstances(inputData);
      System.out.println("instances: " + inst.toString());

    }
    catch (Exception ex) {
      ex.printStackTrace();
    };
  }

  /**
  * Main routine for testing.
  *
  * @param argv parameters (ignored)
  */
  public static void main(String[] argv) {
	  
  }

}