metadataoperations.java

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

      for (int i = 0; i < thisMetaData.getAttributesNumber(); i++) {
        MiningAttribute mAtt = thisMetaData.getMiningAttribute(i);
        if (mAtt instanceof CategoricalAttribute) {
          CategoricalAttribute catAtt = (CategoricalAttribute) mAtt;
          if ( catAtt.isUnboundedCategories() && !catAtt.isUnstoredCategories() )
            catAtt.setUnboundedCategories(false);
        }
      }
    }

    // -----------------------------------------------------------------------
    //  Comparison operations
    // -----------------------------------------------------------------------
    /**
     * Indicates whether a given meta data contains this one.
     *
     * @param metaData meta data with which to compare
     * @return true if this meta data is contained in given one, false otherwise
     */
    public boolean subset(MiningDataSpecification metaData) {

      if ( thisMetaData.getAttributesNumber() > metaData.getAttributesNumber() )
        return false;
      for (int i = 0; i < thisMetaData.getAttributesNumber(); i++) {
        MiningAttribute thisAtt = thisMetaData.getMiningAttribute(i);
        MiningAttribute att     = metaData.getMiningAttribute( thisAtt.getName() );
        if ( att == null )
          return false;
        else {
          if ( usageType != USE_ATT_NAMES && !thisAtt.getClass().equals(att.getClass()) )
            return false;
        }
      }
      return true;
    }

    /**
     * Indicates whether a given meta data is contained in this one.
     *
     * @param metaData meta data with which to compare
     * @return true if this meta data contains the given one, false otherwise
     */
    public boolean superset(MiningDataSpecification metaData) {

      if ( thisMetaData.getAttributesNumber() < metaData.getAttributesNumber() )
        return false;
      for (int i = 0; i < metaData.getAttributesNumber(); i++) {
        MiningAttribute att     = metaData.getMiningAttribute(i);
        MiningAttribute thisAtt = thisMetaData.getMiningAttribute( att.getName() );
        if ( thisAtt == null )
          return false;
        else {
          if ( usageType != USE_ATT_NAMES && !thisAtt.getClass().equals(att.getClass()) )
            return false;
        }
      }
      return true;
    }

    /**
     * Indicates whether a given meta data is equal to this one.
     * Here, equal means that the given meta data has the same number
     * of attributes with the same names as this one.
     *
     * @param metaData meta data with which to compare
     * @return true if meta data is equal, false otherwise
     */
    public boolean equals(MiningDataSpecification metaData) {

      if ( thisMetaData.getAttributesNumber() != metaData.getAttributesNumber() )
        return false;
      for (int i = 0; i < thisMetaData.getAttributesNumber(); i++) {
        MiningAttribute thisAtt = thisMetaData.getMiningAttribute(i);
        MiningAttribute att     = metaData.getMiningAttribute( thisAtt.getName() );
        if ( att == null )
          return false;
        else {
          if ( usageType != USE_ATT_NAMES && !thisAtt.getClass().equals(att.getClass()) )
            return false;
        }
      }
      return true;
    }

    // -----------------------------------------------------------------------
    //  Test
    // -----------------------------------------------------------------------
    /**
     * Test.
     *
     * @param args test parameters
     */
    public static void main(String[] args)
    {
        try
        {
          // ---------------------- create attributes ------------------------
          // Create numeric attribute 'age':
          NumericAttribute age = new NumericAttribute("age");

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

          // Create our well-known categorical attribute 'cutlery':
          CategoricalAttribute cutlery = new CategoricalAttribute("cutlery");
          cutlery.addCategory( new Category("knife") );
          cutlery.addCategory( new Category("fork") );
          cutlery.addCategory( new Category("spoon") );

          // Create second categorical attribute 'cutlery2':
          CategoricalAttribute cutlery2 = new CategoricalAttribute("cutlery");
          cutlery2.addCategory( new Category("spoon") );
          cutlery2.addCategory( new Category("knife") );
          cutlery2.addCategory( new Category("skewer") );
          cutlery2.addCategory( new Category("fork") );

          // ----------------------- guest == guest2 -------------------------
          System.out.println("-------------- guest == guest2 --------------" );

          // Create first meta data 'guest':
          MiningDataSpecification guest = new MiningDataSpecification("guest");
          guest.addMiningAttribute( age );
          guest.addMiningAttribute( weight );
          guest.addMiningAttribute( cutlery );
          System.out.println("meta data 'guest': " + guest);

          // Get meta data operations object of 'guest':
          MetaDataOperations guestOp = guest.getMetaDataOp();

          // Create second meta data 'guest2':
          MiningDataSpecification guest2 = new MiningDataSpecification("guest2");
          guest2.addMiningAttribute( cutlery2 );
          guest2.addMiningAttribute( age );
          guest2.addMiningAttribute( weight );
          System.out.println("meta data 'guest2': " + guest2);

          // Compare bases of both meta data:
          System.out.println("'guest' == 'guest2': " + guestOp.equals(guest2) );
          System.out.println("'guest' subset 'guest2': " + guestOp.subset(guest2) );
          System.out.println("'guest' superset 'guest2': " + guestOp.superset(guest2) );
          System.out.println();

          // Transforms basis of 'guest2' to 'guest' basis:
          MiningDataSpecification transGuest2 = guestOp.transform(guest2);
          System.out.println("transformed 'guest2': " + transGuest2);

          // Create guest 'john' who is 27, weight 78, eates with fork - in basis guest2:
          double[] arr = {3, 27, 78};
          MiningVector john = new MiningVector(arr);
          john.setMetaData(guest2);
          System.out.println("'john' in basis 'guest2': " + john);

          // Transform 'john' from 'guest2' to 'guest' basis:
          MiningVector transJohn = guestOp.transform(john);
          System.out.println("transformed 'john' in basis 'guest': " + transJohn);
          System.out.println();

          // ----------------------- guest < guest2 -------------------------
          System.out.println("-------------- guest < guest2 --------------" );

          // Extend 'guest2' by new attribute 'calories':
          guest2.addMiningAttribute( new NumericAttribute("calories") );
          System.out.println("meta data 'guest': " + guest);
          System.out.println("meta data 'guest2': " + guest2);

          // Compare bases of both meta data:
          System.out.println("'guest' == 'guest2': " + guestOp.equals(guest2) );
          System.out.println("'guest' subset 'guest2': " + guestOp.subset(guest2) );
          System.out.println("'guest' superset 'guest2': " + guestOp.superset(guest2) );
          System.out.println();

          // Transforms basis of 'guest2' to 'guest' basis:
          transGuest2 = guestOp.transform(guest2);
          System.out.println("transformed 'guest2': " + transGuest2);

          // Create guest 'olga' who is 19, weight 56, eates with spoon 19 kcal - in basis guest2:
          double[] arr2 = {0, 19, 56, 19000};
          MiningVector olga = new MiningVector(arr2);
          olga.setMetaData(guest2);
          System.out.println("'olga' in basis 'guest2': " + olga);

          // Transform 'olga' from 'guest2' to 'guest' basis:
          MiningVector transOlga = guestOp.transform(olga);
          System.out.println("transformed 'olga' in basis 'guest': " + transOlga);
          System.out.println();

          // ----------------------- guest <> guest2 -------------------------
          System.out.println("-------------- guest <> guest2 --------------" );

          // Extend 'guest' by new attribute 'cal':
          guest.addMiningAttribute( new NumericAttribute("arrivel") );
          System.out.println("meta data 'guest': " + guest);
          System.out.println("meta data 'guest2': " + guest2);

          // Compare bases of both meta data:
          System.out.println("'guest' == 'guest2': " + guestOp.equals(guest2) );
          System.out.println("'guest' subset 'guest2': " + guestOp.subset(guest2) );
          System.out.println("'guest' superset 'guest2': " + guestOp.superset(guest2) );
          System.out.println();

          // Transforms basis of 'guest2' to 'guest' basis again:
          transGuest2 = guestOp.transform(guest2);
          System.out.println("transformed 'guest2': " + transGuest2);

          // Transform 'olga' from 'guest2' to 'guest' basis again:
          transOlga = guestOp.transform(olga);
          System.out.println("transformed 'olga' in basis 'guest': " + transOlga);
          System.out.println();

          // Set usage type to extended mode:
          guestOp.setUsageType(USE_ATT_NAMES_AND_TYPES);
          System.out.println("Now usage type USE_ATT_NAMES_AND_TYPES");

          // Transforms basis of 'guest2' to 'guest' basis once more:
          transGuest2 = guestOp.transform(guest2);
          System.out.println("transformed 'guest2': " + transGuest2);

          // Transform 'olga' from 'guest2' to 'guest' basis once more:
          transOlga = guestOp.transform(olga);
          System.out.println("transformed 'olga' in basis 'guest': " + transOlga);
          System.out.println();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}