apriori.java

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

    if (minimumSupportCount <= 0)
      transSet.setMinSuppCount(minimumSupport);
    else
      transSet.setMinSuppCount(minimumSupportCount);
    int minSuppCount = transSet.getMinSuppCount();
    if (dbg) System.out.println("minSuppCount = " + minSuppCount);

    // Find large 1-itemsets:
    int itemSetSize = 1;
    ItemSetList itemSetList = new ItemSetList(); //contains "ItemSet"s
    largeItemSetList        = transSet.buildHashTable();
    if (dbg) System.out.println("Large 1-Itemsets w/ minSuppCount:");
    if (dbg) largeItemSetList.print();

    // Convert the large 1-itemsets to a tree
    ItemTree itree = new ItemTree(largeItemSetList);
    itree.setTransactionSet(transSet);

    // Find remaining large itemsets:
    int depth = 1000;
    if (maximumItemSize > -1)
      depth = maximumItemSize;
    for (int i = 1; i < depth; i++) {
      if (! itree.filltree(i) )
        break;
    };
    if (dbg) itree.printtree(itree.tree);

    return itree;
  }

  /**
   * Create transaction set from input stream.
   *
   * @param miningInputStream mining input stream to be converted
   * @return transaction set of minig input stream
   * @exception MiningException cannot convert mining input stream
   */
  private TransactionSet convertMiningInputStream( MiningInputStream miningInputStream ) throws MiningException
  {
    TransactionSet ts = new TransactionSet();
    ItemSet set;
    Hashtable itemSets = new Hashtable( 100 );
    MiningVector vector;
    double transId;
    double itemId;

    // Go through input stream and write in hashtable:
    while( miningInputStream.next() )
    {
       vector = miningInputStream.read();
// +++ Invalid vector => ignore:
       if (vector == null)
          continue;
// --- Invalid vector, ignore.
       transId = vector.getValue( categoryTransactId );
       itemId = vector.getValue( categoryItemId );

       // Missing value => ignore line:
       if ( Category.isMissingValue(transId) || Category.isMissingValue(itemId) )
         continue;

       Double key = new Double( transId );
       set = (ItemSet)itemSets.get( key );
       if( set != null )
       {
          set.addItem( (int)itemId );

// ++++++ Include Taxonomy:
          if (useTaxonomy) {
            // Add parent items to itemset:
            IntVector parItems = getParentItemKeys( (int)itemId );
            for (int i = 0; i < parItems.size(); i++)
              set.addItem( parItems.IntegerAt(i) );
          };
// ------ Included Taxonomy.

        }
        else
        {
           set = new ItemSet();

           set.addItem( (int)itemId );

// +++++++ Include Taxonomy:
           if (useTaxonomy) {
             // Add parent items to itemset:
             IntVector parItems = getParentItemKeys( (int)itemId );
             for (int i = 0; i < parItems.size(); i++)
               set.addItem( parItems.IntegerAt(i) );
           };
// ------- Included Taxonomy.

           itemSets.put( key, set );
        };
    };

    // Convert hashtable to transaction set:
    Iterator it = itemSets.values().iterator();
    while( it.hasNext() )
    {
      set = (ItemSet)( it.next() );
      ts.addTransaction( set );
      set.print();
    };

    return ts;
  }

/******************************************************************************/
/*                                                                            */
/**************** BEGIN: OLD OPERATIONS ***************************************/
  /**
   * Implements the Algorithm Apriori (by Rakesh Agrawal).
   *
   * @param transSet transaction set
   * @param minsupp minimal support
   * @param minconf minimal confidence
   * @return result as list of association rules
   */
  public static AprioriResult AprioriAlg(TransactionSet transSet,
                                        double minsupp, double minconf) {

    return AprioriAlg(transSet, minsupp, minconf, 1, -1);
  }

  /**
   * Implements the Algorithm Apriori (by Rakesh Agrawal).
   *
   * @param transSet transaction set
   * @param minsupp minimal support
   * @param minconf minimal confidence
   * @param minItemSize minimum size of rules
   * @param maxItemSize maximum size of rules, -1 for unbounded
   * @return result as list of association rules
   */
  public static AprioriResult AprioriAlg(TransactionSet transSet,
                                         double minsupp, double minconf,
                                         int minItemSize, int maxItemSize) {

    // Init transaction set:
    transSet.init();

    // Create list of large itemsets:
    ItemSetList largeItemSetList = new ItemSetList();

    // Determine minimal support:
    transSet.setMinSuppCount(minsupp);
    int minSuppCount = transSet.getMinSuppCount();
    if (dbg) System.out.println("minSuppCount = " + minSuppCount);

    // Find large 1-itemsets:
    int itemSetSize = 1;
    ItemSetList itemSetList = new ItemSetList(); //contains "ItemSet"s
    largeItemSetList        = transSet.buildHashTable();
    if (dbg) System.out.println("Large 1-Itemsets w/ minSuppCount:");
    if (dbg) largeItemSetList.print();

    // Convert the large 1-itemsets to a tree
    ItemTree itree = new ItemTree(largeItemSetList);
    itree.setTransactionSet(transSet);

    // Find remaining large itemsets:
    int depth = 1000;
    if (maxItemSize > -1)
      depth = maxItemSize;
    for (int i = 1; i < depth; i++) {
      if (! itree.filltree(i) )
        break;
    };
    if (dbg) itree.printtree(itree.tree);

    // Find association rules:
    RuleSetList ruleSetList = new RuleSetList();
    if (dbg) System.out.println("Now generating association rules...");
    largeItemSetList = itree.genrules(transSet, ruleSetList, minconf);

    // Create and return result:
    return new AprioriResult(ruleSetList, largeItemSetList);
 }


  /**
   * Implements the part of finding large itemsets of
   * Algorithm Apriori (by Rakesh Agrawal).
   *
   * @param transSet transaction set
   * @param minsupp minimal support
   * @return result as list of large itemsets
   */
  protected static ItemSetList AprioriAlgLITS(TransactionSet transSet,
                                           double minsupp) {

    return AprioriAlgLITS(transSet, minsupp, 1, -1);
  }

  /**
   * Implements the part of finding large itemsets of
   * Algorithm Apriori (by Rakesh Agrawal).
   *
   * @param transSet transaction set
   * @param minsupp minimal support
   * @param minItemSize minimum size of rules
   * @param maxItemSize maximum size of rules, -1 for unbounded
   * @return result as list of large itemsets
   */
  protected static ItemSetList AprioriAlgLITS(TransactionSet transSet,
                                           double minsupp,
                                           int minItemSize, int maxItemSize) {

    // Create list of large itemsets:
    ItemSetList largeItemSetList = new ItemSetList();

    // Determine minimal support:
    transSet.setMinSuppCount(minsupp);
    int minSuppCount = transSet.getMinSuppCount();
    if (dbg) System.out.println("minSuppCount = " + minSuppCount);

    // Find large 1-itemsets:
    int itemSetSize = 1;
    ItemSetList itemSetList = new ItemSetList(); //contains "ItemSet"s
    largeItemSetList        = transSet.buildHashTable();
    if (dbg) System.out.println("Large 1-Itemsets w/ minSuppCount:");
    if (dbg) largeItemSetList.print();

    // Convert the large 1-itemsets to a tree
    ItemTree itree = new ItemTree(largeItemSetList);
    itree.setTransactionSet(transSet);

    // Find remaining large itemsets:
    int depth = 1000;
    if (maxItemSize > -1)
      depth = maxItemSize;
    for (int i = 1; i < depth; i++) {
      if (! itree.filltree(i) )
        break;
    };
    if (dbg) itree.printtree(itree.tree);

    // Copy large itemsets:
    largeItemSetList = itree.getLargeItemSetList(itree.tree);
    if (dbg) System.out.println("L A R G E  Itemset list:");
    if (dbg) largeItemSetList.print();

    return largeItemSetList;
 }

/****************** END: OLD OPERATIONS ***************************************/
/*                                                                            */
/******************************************************************************/
}