InfreqRemover_AssocRuleGen.hpp

Go to the documentation of this file.

#ifndef InfreqRemover_AssocRuleGen_HPP
#define InfreqRemover_AssocRuleGen_HPP

#include "common.hpp"
#include "common/Edge.hpp"
#include "apriori/bodon/inhomogeneous_trie/trie_manipulators/InfreqRemover.hpp"
#include <vector>
//#include <cstdio>
//#include <iterator>   //for test




namespace Bodon
{
namespace inhomogeneous_trie
{
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR, 
             NEELevel NEE, bool DEADENDPRUNE = true>
   class InfreqRemover_AssocRuleGen : public InfreqRemover
   <DF_D, TRIE, LEAF, LEAF_ALLOCATOR, NEE, DEADENDPRUNE>
   {
      protected:
         typedef InfreqRemover
         <DF_D, TRIE, LEAF, LEAF_ALLOCATOR, NEE, DEADENDPRUNE> PARENT;
         float min_conf; 
         float min_lift;
         counter_t nr_of_transaction;
         

      public:
         InfreqRemover_AssocRuleGen( 
            TRIE& main_trie, DF_D& df_decoder, LEAF_ALLOCATOR& s_alloc, 
            float min_conf, float min_intr, counter_t nr_of_transaction) : 
            PARENT(main_trie, df_decoder, s_alloc),
            min_conf(min_conf), min_lift(min_lift), 
            nr_of_transaction(nr_of_transaction){}

         void afterWorkDel();

      protected:
         void generateUnions( TRIE* subtrie, std::vector<item_t>& union_set);
         void generateAssocRules( 
            std::vector<item_t>& antecedent_set, std::set<item_t>& conseq_set,
            const counter_t union_support);

         bool generateAnAssociationRule( 
            std::vector<item_t>& antecedent_set, 
            std::set<item_t>& conseq_set, const counter_t union_support);
   };


   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR, 
             NEELevel NEE, bool DEADENDPRUNE> inline
   void InfreqRemover_AssocRuleGen<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, 
                                   NEE, DEADENDPRUNE>::
   afterWorkDel()
   {
      if(!DEADENDPRUNE)
         if(NEE > NEE_Off)
         {
            std::vector<item_t> NEEsum;
            PARENT::destroyAndWriteNEE(&this->main_trie, NEEsum);
         }
         else
         {
            log_status(0,"Generating association rules.");
            std::vector<item_t> union_set;
            generateUnions(&this->main_trie, union_set);
            PARENT::destroy(&this->main_trie);
         }
   }

   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR, 
             NEELevel NEE, bool DEADENDPRUNE>
   void InfreqRemover_AssocRuleGen<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, 
                                   NEE, DEADENDPRUNE>::
   generateUnions( TRIE* subtrie, std::vector<item_t>& union_set)
   {
      for(typename TRIE::iterator itEdge( subtrie->edgelist.begin() ); 
          itEdge != subtrie->edgelist.end(); ++itEdge)
      {
         union_set.push_back((*itEdge).first);
         std::set<item_t> conseq_set;
         generateAssocRules(union_set, conseq_set, this->main_trie.isIncluded
                            ( union_set, union_set.begin() )->getCounter());
         generateUnions( static_cast<TRIE*>((*itEdge).second), union_set );
         union_set.pop_back();
      }
   }
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR, 
             NEELevel NEE, bool DEADENDPRUNE>
   void InfreqRemover_AssocRuleGen<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, 
                                   NEE, DEADENDPRUNE>::
   generateAssocRules( 
      std::vector<item_t>& antecedent_set, std::set<item_t>& conseq_set,
      const counter_t union_support)
   {
      if(antecedent_set.size() > 1)
      {
         std::vector<item_t>::iterator it = antecedent_set.begin();
         register item_t replaced_item = *it, temp_item;
         antecedent_set.erase(it);
         conseq_set.insert(replaced_item);
         if( generateAnAssociationRule(
                antecedent_set, conseq_set, union_support) )
            generateAssocRules(antecedent_set, conseq_set, union_support);
         conseq_set.erase(replaced_item);
         while (it != antecedent_set.end() )
         {
            temp_item = *it;
            *it = replaced_item;
            ++it;
            replaced_item = temp_item;
            conseq_set.insert(replaced_item);
            if( generateAnAssociationRule(antecedent_set, conseq_set, union_support) )
               generateAssocRules(antecedent_set, conseq_set, union_support);
            conseq_set.erase(replaced_item);
         }
         antecedent_set.push_back( replaced_item );
      }
   }

   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR, 
             NEELevel NEE, bool DEADENDPRUNE> inline
   bool InfreqRemover_AssocRuleGen<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, 
                                   NEE, DEADENDPRUNE>::
   generateAnAssociationRule( 
      std::vector<item_t>& antecedent_set, 
      std::set<item_t>& conseq_set, const counter_t union_support)
   {
      counter_t antec_supp = this->main_trie.isIncluded(
         antecedent_set, antecedent_set.begin())->getCounter();
      counter_t conseq_supp = this->main_trie.isIncluded(
         conseq_set, conseq_set.begin())->getCounter();
      float confidence = static_cast<float>(union_support) / antec_supp;
      if(confidence >= min_conf)
      {
         float lift = confidence * (static_cast<float>(nr_of_transaction) / 
                                    conseq_supp);
         if(lift >= min_lift)
            PARENT::df_decoder.writeAssocRule(
               antecedent_set.begin(), antecedent_set.end(),
               conseq_set.begin(), conseq_set.end(),
               union_support, confidence, lift);
         return true;
      }
      else
         return false;

   }
}
}
#endif

---