source: src/main/java/weka/associations/LabeledItemSet.java @ 10

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

/*
 * LabeledItemSet.java
 * Copyright (C) 2004 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.associations;

import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.RevisionHandler;
import weka.core.RevisionUtils;

import java.io.Serializable;
import java.util.Enumeration;
import java.util.Hashtable;


/**
 * Class for storing a set of items together with a  class label. Item sets are stored in a lexicographic
 * order, which is determined by the header information of the set of instances
 * used for generating the set of items. All methods in this class assume that
 * item sets are stored in lexicographic order.
 * The class provides the methods used for item sets in class association rule mining.
 * Because every item set knows its class label the training set can be splitted up virtually.
 *
 * @author Stefan Mutter (mutter@cs.waikato.ac.nz)
 * @version $Revision: 1.5 $
 */

public class LabeledItemSet
  extends ItemSet
  implements Serializable, RevisionHandler {

  /** for serialization */
  private static final long serialVersionUID = 4158771925518299903L;

    /** The class label. */
    protected int m_classLabel;

     /** The support of the rule. */
    protected int m_ruleSupCounter;    
  
    /**
     * Constructor
     *
     * @param totalTrans the total number of transactions
     * @param classLabel the class lebel
     */    
    public LabeledItemSet(int totalTrans, int classLabel){
        
        super(totalTrans);
        m_classLabel = classLabel;
    }

    

    /**
     * Deletes all item sets that don't have minimum support and have more than maximum support
     * @return the reduced set of item sets
     * @param maxSupport the maximum support
     * @param itemSets the set of item sets to be pruned
     * @param minSupport the minimum number of transactions to be covered
     */
  public static FastVector deleteItemSets(FastVector itemSets, 
                                          int minSupport,
                                          int maxSupport) {

    FastVector newVector = new FastVector(itemSets.size());

    for (int i = 0; i < itemSets.size(); i++) {
      LabeledItemSet current = (LabeledItemSet)itemSets.elementAt(i);
      if ((current.m_ruleSupCounter >= minSupport) 
          && (current.m_ruleSupCounter <= maxSupport))
            newVector.addElement(current);
    }
    return newVector;
  }

    /**
   * Tests if two item sets are equal.
   *
   * @param itemSet another item set
   * @return true if this item set contains the same items as the given one
   */
  public final boolean equals(Object itemSet) {

    if (!(this.equalCondset(itemSet)))
      return false;
    if(m_classLabel != ((LabeledItemSet)itemSet).m_classLabel)
        return false;
    
    return true;
  }

  /**
   * Compares two item sets
   * @param itemSet an item set
   * @return true if the the item sets are equal, false otherwise
   */  
    public final boolean equalCondset(Object itemSet) {

    if ((itemSet == null) || !(itemSet.getClass().equals(this.getClass()))) {
      return false;
    }
    if (m_items.length != ((ItemSet)itemSet).items().length)
      return false;
    for (int i = 0; i < m_items.length; i++)
      if (m_items[i] != ((ItemSet)itemSet).itemAt(i))
        return false;
    return true;
  }

    /**
   * Return a hashtable filled with the given item sets.
   *
   * @param itemSets the set of item sets to be used for filling the hash table
   * @param initialSize the initial size of the hashtable
   * @return the generated hashtable
   */
  public static Hashtable getHashtable(FastVector itemSets, int initialSize) {

    Hashtable hashtable = new Hashtable(initialSize);
    for (int i = 0; i < itemSets.size(); i++) {
      LabeledItemSet current = (LabeledItemSet)itemSets.elementAt(i);
      hashtable.put(current, new Integer(current.m_classLabel));
    }
   
    return hashtable;
  }



    /**
     * Merges all item sets in the set of (k-1)-item sets
     * to create the (k)-item sets and updates the counters.
     * @return the generated (k)-item sets
     * @param totalTrans the total number of transactions
     * @param itemSets the set of (k-1)-item sets
     * @param size the value of (k-1)
     */
  public static FastVector mergeAllItemSets(FastVector itemSets, int size, 
                                            int totalTrans) {
      
      FastVector newVector = new FastVector();
      LabeledItemSet result;
      int numFound, k;
      
      for (int i = 0; i < itemSets.size(); i++) {
          LabeledItemSet first = (LabeledItemSet)itemSets.elementAt(i);
      out:
          for (int j = i+1; j < itemSets.size(); j++) {
              LabeledItemSet second = (LabeledItemSet)itemSets.elementAt(j);
              while(first.m_classLabel != second.m_classLabel){
                  j++;
                  if(j == itemSets.size())
                      break out;
                  second = (LabeledItemSet)itemSets.elementAt(j);
              }
              result = new LabeledItemSet(totalTrans,first.m_classLabel);
              result.m_items = new int[first.m_items.length];
              
              // Find and copy common prefix of size 'size'
              numFound = 0;
              k = 0;
              while (numFound < size) {
                  if (first.m_items[k] == second.m_items[k]) {
                      if (first.m_items[k] != -1) 
                          numFound++;
                      result.m_items[k] = first.m_items[k];
                  } else 
                      break out;
                  k++;
              }
              
              // Check difference
              while (k < first.m_items.length) {
                  if ((first.m_items[k] != -1) && (second.m_items[k] != -1))
                      break;
                  else {
                      if (first.m_items[k] != -1)
                          result.m_items[k] = first.m_items[k];
                      else
                          result.m_items[k] = second.m_items[k];
                  }
                  k++;
              }
              if (k == first.m_items.length) {
                  result.m_ruleSupCounter = 0;
                  result.m_counter = 0;
                  newVector.addElement(result);
              }
          }
      }
      
    return newVector;
  }
    
  /**
   * Splits the class attribute away. Depending on the invert flag, the instances without class attribute or only the class attribute of all instances is returned
   * @param instances the instances
   * @param invert flag; if true only the class attribute remains, otherweise the class attribute is the only attribute that is deleted.
   * @throws Exception exception if instances cannot be splitted
   * @return Instances without the class attribute or instances with only the class attribute
   */  
    public static Instances divide(Instances instances, boolean invert) throws Exception{
    
        Instances newInstances = new Instances(instances);
        if(instances.classIndex() < 0)
            throw new Exception("For class association rule mining a class attribute has to be specified.");
        if(invert){
                for(int i=0;i<newInstances.numAttributes();i++){
                    if(i!=newInstances.classIndex()){
                        newInstances.deleteAttributeAt(i);
                        i--;
                    }
                }
            return newInstances;
        }
        else{
            newInstances.setClassIndex(-1);
            newInstances.deleteAttributeAt(instances.classIndex());
            return newInstances;
        }
    }

   
    
     /**
      * Converts the header info of the given set of instances into a set
      * of item sets (singletons). The ordering of values in the header file
      * determines the lexicographic order. Each item set knows its class label.
      * @return a set of item sets, each containing a single item
      * @param instancesNoClass instances without the class attribute
      * @param classes the values of the class attribute sorted according to instances
      * @exception Exception if singletons can't be generated successfully
      */
    public static FastVector singletons(Instances instancesNoClass, Instances classes) throws Exception {

    FastVector cSet, setOfItemSets = new FastVector();
    LabeledItemSet current;
    
    
    //make singletons
    for (int i = 0; i < instancesNoClass.numAttributes(); i++) {
      if (instancesNoClass.attribute(i).isNumeric())
          throw new Exception("Can't handle numeric attributes!");
      for (int j = 0; j < instancesNoClass.attribute(i).numValues(); j++){
          for(int k =0; k < (classes.attribute(0)).numValues(); k++){
              current = new LabeledItemSet(instancesNoClass.numInstances(),k);
              current.m_items = new int[instancesNoClass.numAttributes()];
              for (int l = 0; l < instancesNoClass.numAttributes(); l++)
                  current.m_items[l] = -1;
              current.m_items[i] = j;
              setOfItemSets.addElement(current);
          }      
      }
    }
    return setOfItemSets;
  }
    
 
    
  
    /**
   * Prunes a set of (k)-item sets using the given (k-1)-item sets.
   *
   * @param toPrune the set of (k)-item sets to be pruned
   * @param kMinusOne the (k-1)-item sets to be used for pruning
   * @return the pruned set of item sets
   */
  public static FastVector pruneItemSets(FastVector toPrune, Hashtable kMinusOne){

    FastVector newVector = new FastVector(toPrune.size());
    int help, j;

   
    for (int i = 0; i < toPrune.size(); i++) {
      LabeledItemSet current = (LabeledItemSet)toPrune.elementAt(i);
      
      for (j = 0; j < current.m_items.length; j++){
              if (current.m_items[j] != -1) {
                  help = current.m_items[j];
                  current.m_items[j] = -1;
                  if(kMinusOne.get(current) != null && (current.m_classLabel == (((Integer)kMinusOne.get(current)).intValue())))
                      current.m_items[j] = help;
                  else{
                      current.m_items[j] = help;
                      break;
                  } 
          }
      }
      if (j == current.m_items.length) 
        newVector.addElement(current);
    }
    return newVector;
  }

    
  /**
   * Outputs the support for an item set.
   *
   * @return the support
   */
  public final int support() {

    return m_ruleSupCounter;
  }

  
  
     /**
      * Updates counter of item set with respect to given transaction.
      * @param instanceNoClass instances without the class attribute
      * @param instanceClass the values of the class attribute sorted according to instances
      */
  public final void upDateCounter(Instance instanceNoClass, Instance instanceClass) {

     
      if (containedBy(instanceNoClass)){
          m_counter++;
          if(this.m_classLabel == instanceClass.value(0))
              m_ruleSupCounter++;
      }
  }

  /**
   * Updates counter of a specific item set
   * @param itemSets an item sets
   * @param instancesNoClass instances without the class attribute
   * @param instancesClass the values of the class attribute sorted according to instances
   */  
   public static void upDateCounters(FastVector itemSets, Instances instancesNoClass, Instances instancesClass){

    for (int i = 0; i < instancesNoClass.numInstances(); i++) {
        Enumeration enu = itemSets.elements();
        while (enu.hasMoreElements())
            ((LabeledItemSet)enu.nextElement()).upDateCounter(instancesNoClass.instance(i),instancesClass.instance(i));
    }

  }

   /**
    * Generates rules out of item sets
    * @param minConfidence the minimum confidence
    * @param noPrune flag indicating whether the rules are pruned accoridng to the minimum confidence value
    * @return a set of rules
    */   
    public final FastVector[] generateRules(double minConfidence, boolean noPrune) {

        FastVector premises = new FastVector(),consequences = new FastVector(),
            conf = new FastVector();
        FastVector[] rules = new FastVector[3];
        ItemSet premise, consequence;
        
    // Generate all rules with class in the consequence. 
        premise = new ItemSet(m_totalTransactions);
        consequence = new ItemSet(m_totalTransactions);
        int[] premiseItems = new int[m_items.length];
        int[] consequenceItems = new int[1];
        System.arraycopy(m_items, 0, premiseItems, 0, m_items.length);
        consequence.setItem(consequenceItems);
        premise.setItem(premiseItems);
        consequence.setItemAt(m_classLabel,0);
        consequence.setCounter(this.m_ruleSupCounter);
        premise.setCounter(this.m_counter);
        premises.addElement(premise);
        consequences.addElement(consequence);
        conf.addElement(new Double((double)this.m_ruleSupCounter/(double)this.m_counter));
            
        rules[0] = premises;
        rules[1] = consequences;
        rules[2] = conf;
        if(!noPrune)
            pruneRules(rules, minConfidence);
        
    
        return rules;
    }
    
    /**
     * Returns the revision string.
     * 
     * @return          the revision
     */
    public String getRevision() {
      return RevisionUtils.extract("$Revision: 1.5 $");
    }
}