associationrulesdecompalgorithm.java

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

        // Get full itemset if large itemset:
        ItemSet full = new ItemSet(prem);
        for (int i = 0; i < conc.getSize(); i++)
          full.addItem( conc.getItemAt(i) );
        Integer SuppAUB = (Integer) lits.get(full);
        if (SuppAUB == null || SuppAUB.intValue() == 0 ) {
          rules.remove(rs);
          continue;
        };

        // Calculate support and confidence:
        double supp = ((double) SuppAUB.intValue()) / nTrans;
        double conf = ((double) SuppAUB.intValue()) / SuppA.intValue();
        if (conf < minimumConfidence) {
          rules.remove(rs);
          continue;
        };

        // Store support and confidence in rule:
        rs.support    = supp;
        rs.confidence = conf;
      };

      fireMiningEvent(new CreationModelEndMessageAssociationRules(rules.size(), lits.size(), this.getAlgorithmLevel()));
    }

    /**
     * Returns number of transactions. Overwrites same method from
     * AssociationRulesAlgorithm because here the transactions are
     * really counted what also works for transaction ID attributes
     * of 'unstoredCategories' type.
     *
     * @return number of transactions, -1 if unknown
     */
    public int getNumberOfTransactions() {

      return numberOfTransactions;
    }

    /**
     * Runs association rules algorithm on local domain.
     *
     * @param msd data source
     * @return association rules model
     * @throws MiningException cannot run algorithm
     */
    private AssociationRulesMiningModel runAlgorithmLocal(MiningStoredData msd)
      throws MiningException {

      // Set mining settings with local transaction attribute:
      AssociationRulesSettings miningSettingsLoc = (AssociationRulesSettings) miningSettings;
      miningSettingsLoc.setTransactionId(transactIdLoc);

      // Get default mining algorithm specification from 'algorithms.xml':
      MiningAlgorithmSpecification miningAlgorithmSpecification =
        MiningAlgorithmSpecification.getMiningAlgorithmSpecification( algorithmName, null );
      if( miningAlgorithmSpecification == null )
        throw new MiningException( "Can't find application " + algorithmName );

      // Get class name from algorithms specification:
      String className = miningAlgorithmSpecification.getClassname();
      if( className == null )
        throw new MiningException( "className attribute of algorithmName expected." );

      // Set and display mining parameters:
      setMinimumItemSize(miningAlgorithmSpecification, 1);
      setMaximumItemSize(miningAlgorithmSpecification, maximumItemSize);

      // Create algorithm object with default values:
      AssociationRulesAlgorithm algorithm = (AssociationRulesAlgorithm)
          GeneralUtils.createMiningAlgorithmInstance(className);

      algorithm.setParentAlgorithm(this);
      
      // Put it all together:
      algorithm.setMiningInputStream( msd );
      algorithm.setMiningSettings( miningSettingsLoc );
      algorithm.setMiningAlgorithmSpecification( miningAlgorithmSpecification );
      algorithm.setUseTaxonomy( useTaxonomy );
      algorithm.verify();

      // Build the mining model:
      AssociationRulesMiningModel model = (AssociationRulesMiningModel) algorithm.buildModel();

      // Change settings back:
      ((AssociationRulesSettings) miningSettings).setTransactionId(categoryTransactId);

      return model;
    }

    /**
     * Adds new large itemsets to hashtable lits.
     *
     * @param largeITS large itemsets calculated in current domain
     */
    private void addLargeItemSets(Vector largeITS) {

      for (int i = 0 ; i < largeITS.size(); i++)
      {
        ItemSet lit = (ItemSet) largeITS.elementAt(i);
        if (lits.get(lit) == null)
          lits.put( lit, new Integer(0) );
      };
    }

    /**
     * Adds new association rule to hashtable rules.
     *
     * @param assRules association rules calculated in current domain
     */
    private void addAssociationRules(Vector assRules) {

      for (int i = 0 ; i < assRules.size(); i++)
      {
        RuleSet rule = (RuleSet) assRules.elementAt(i);
        if (rules.get(rule) == null)
          rules.put(rule, new Integer(0) );
      };
    }

    /**
     * Updates support and confidence values of rules and large itemsets
     * according to new data set.
     *
     * @param msd data set for updating rules and large itemsets
     * @exception MiningException cannot read data from msd
     */
    private void updateSuppConf(MiningStoredData msd) throws MiningException{

      // Initialize itemTrans:
      int nLit = itemTrans.length;
      for (int i = 0; i < nLit; i++)
        itemTrans[i] = new IntVector();

      // Loop over all data to fill itemTrans:
      while (msd.next()) {

        // Read new mining vector with item and transaction IDs:
        MiningVector vector = msd.read();
        int transId = (int) vector.getValue( transactIdLoc );
        int itemId  = (int) vector.getValue( categoryItemId );

        // Add transaction ID to itemTrans if large item:
        Integer Item = largeItems.get(itemId);   // num of large item

        // Item is large item => add transaction:
        if (Item != null) {
          int ind      = Item.intValue();
          boolean cont = false;
          for (int i = 0; i < itemTrans[ind].size(); i++)
            if (itemTrans[ind].IntegerAt(i) == transId)
              cont = true;
          if (!cont)
            itemTrans[ind].addElement(transId);
        };

        // If taxonomy used, find all large parent items and add to itemTrans:
        if (useTaxonomy) {
          IntVector parItems = getParentItemKeys( itemId );
          for (int i = 0; i < parItems.size(); i++) {
             int parit = parItems.IntegerAt(i);
             Item      = largeItems.get(parit);   // num of large item
             if (Item != null) {
               int ind      = Item.intValue();
               boolean cont = false;
               for (int j = 0; j < itemTrans[ind].size(); j++)
                 if (itemTrans[ind].IntegerAt(j) == transId)
                   cont = true;
               if (!cont)
                 itemTrans[ind].addElement(transId);
             };
          };
        };
      };

      // Check all large itemsets and update support count:
      Enumeration em = lits.keys();
      while ( em.hasMoreElements() ) {
        ItemSet is = (ItemSet) em.nextElement();
        int nTrans = getTransactNumbers(is).size();
        int nSCNew = is.getSupportCount() + nTrans;
        is.setSupportCount(nSCNew);
      };
    }

    /**
     * Get numbers of all transactions which include the given itemset.
     *
     * @param items itemset to be looked for
     * @return numbers of all transactions including items
     */
    private IntVector getTransactNumbers(ItemSet items) {

      IntVector transVec    = new IntVector();
      IntHashtable itemHash = new IntHashtable();

      // Number of items in itemset:
      int nitems = items.getSize();

      // Construct hashtable with transaction numbers as keys and number of
      // items as value:
      for (int i = 0; i < nitems; i++) {
        Integer iTem = largeItems.get(items.getIntegerAt(i));
        for (int j = 0; j < itemTrans[iTem.intValue()].size(); j++) {
          int it         = itemTrans[iTem.intValue()].IntegerAt(j);
          Integer iTrans = itemHash.get(it);
          if (iTrans == null)
            itemHash.put(it, 1);
          else
            itemHash.put(it, iTrans.intValue()+1);
        };
      };

      // Now check all keys and only use those values are equal to nitems,
      // i.e. those transactions which include all given large items:
      Enumeration em = itemHash.keys();
      while (em.hasMoreElements()) {
        Integer Item = (Integer) em.nextElement();
        Integer Numb = (Integer) itemHash.get(Item);
        if (Numb.intValue() == nitems)
          transVec.addElement(Item);
      };

      return transVec;
    }

    /**
     * Returns association rules.
     *
     * @return association rules
     */
    protected Vector getAssociationRules() {

      Vector associationRules = new Vector();

      Enumeration em = rules.keys();
      while ( em.hasMoreElements() )
        associationRules.addElement( em.nextElement() );

      return associationRules;
    }

    /**
     * Returns large itemsets.
     *
     * @return large itemsets
     */
    protected Vector getLargeItemSets() {

      Vector largeItemSets = new Vector();

      Enumeration em = lits.keys();
      while (em.hasMoreElements() )
        largeItemSets.addElement( em.nextElement() );

      return largeItemSets;
    }

    /**
     * Returns maximum number of transactions in decomposition.
     *
     * @return maximum number of transactions in decomposition
     */
    public int getDecompSize()
    {
      return decompSize;
    }

    /**
     * Sets new maximum number of transactions in decomposition.
     *
     * @param decompSize new maximum number of transactions in decomposition
     */
    public void setDecompSize(int decompSize)
    {
      this.decompSize = decompSize;
    }

    /**
     * Returns name of local association rules algorithm.
     *
     * @return name of local association rules algorithm
     */
    public String getAlgorithmName()
    {
      return algorithmName;
    }

    /**
     * Sets name of local association rules algorithm.
     *
     * @param algorithmName new name of local association rules algorithm
     */
    public void setAlgorithmName(String algorithmName)
    {
      this.algorithmName = algorithmName;
    }

    /**
     * Exclude last domain from local rule generation (default: false).
     *
     * @return true if exclude, otherwise false
     */
    public boolean isSkipLastDomain()
    {
      return skipLastDomain;
    }

    /**
     * Set exclude last domain from local rule generation (default: false).
     *
     * @param skipLastDomain true if exclude, otherwise false
     */
    public void setSkipLastDomain(boolean skipLastDomain)
    {
      this.skipLastDomain = skipLastDomain;
    }

    /**
     * Sets maximum length of rules.
     *
     * @param maximumItemSize new maximum length of rules
     */
    public void setMaximumItemSize(int maximumItemSize)
    {
        this.maximumItemSize = maximumItemSize;
    }

    /**
     * Sets new minimum length of rules.
     *
     * @param minimumItemSize new minimum length of rules
     */
    public void setMinimumItemSize(int minimumItemSize)
    {
        this.minimumItemSize = minimumItemSize;
    }

    /**
     * Sets minimum item size.
     *
     * @param miningAlgorithmSpecification mining algorithm specification
     * @param minItemSize minimum item size
     */
    private static void setMinimumItemSize(MiningAlgorithmSpecification miningAlgorithmSpecification, int minItemSize) {

      MiningAlgorithmParameter[] attribute = miningAlgorithmSpecification.getInputAttribute();
      for (int i = 0; i < attribute.length; i++) {
        if (attribute[i].getName().equals("minimumItemSize"))
          attribute[i].setValue(String.valueOf(minItemSize));
      };
    }

    /**
     * Sets maximum item size.
     *
     * @param miningAlgorithmSpecification mining algorithm specification
     * @param maxItemSize maximum item size
     */
    private static void setMaximumItemSize(MiningAlgorithmSpecification miningAlgorithmSpecification,int maxItemSize) {

      MiningAlgorithmParameter[] attribute = miningAlgorithmSpecification.getInputAttribute();
      for (int i = 0; i < attribute.length; i++) {
        if (attribute[i].getName().equals("maximumItemSize"))
          attribute[i].setValue(String.valueOf(maxItemSize));
      };
    }
}