AprioriSelector2.hpp

Go to the documentation of this file.

#ifndef AprioriSelector2_HPP
#define AprioriSelector2_HPP

#include "common/allocators.hpp"
#include "util/Frequent2Filter.cpp"
//#include "util/Frequent2FilterOnline.cpp"
#include "io/input/transaction_reader/SortedTransactionReader.hpp" 
#include "io/input/transaction_reader/OrderReverser.hpp"
#include "io/db_cache/transaction_shrinker/RBTreeDBCacheSimultaneous.hpp"
#include "io/db_cache/transaction_shrinker/RBTreeDBCacheInsertThenDestroySimple.hpp"
#include "io/db_cache/transaction_shrinker/RBTreeDBCacheInsertThenDestroyPro.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/FrequentItemInserter.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/FrequentPairInserter.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/IntersectProPruner.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/CandidateGeneratorPrune.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/InfreqRemover.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/SupportCounter.hpp"
#include "apriori/bodon/dynamic_trie/trie_manipulators/SupportCounterFilter.hpp"
#include "apriori/OneByOneSupportCounter.hpp"
#include "apriori/OneByOneSupportCounterANDTransactionFiltering.hpp"
#include "io/db_cache/BuildTreeDBCache.hpp"

#include "apriori/Apriori.hpp"

template <class TRIE_OEL, class TRIE_OI, class LEAF_WC, 
          class T_R, class DF_D, NEELevel NEE> 
class AprioriSelector2
{
   public:
      AprioriSelector2( counter_t min_supp, char* input_file,
                        counter_t nr_of_transactions, 
                        std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters, 
                        T_R& tr_reader, DF_D& df_decoder,
                        TRIE_OEL& main_trie, char *trcache_option, char* ordering_option, 
                        unsigned int maxsize );
   private:
      template <class S_C, class SUPP_C, class IR, class FII, 
                class FPI, class CG, class LEAF_ALLOCATOR> 
      void StartApriori( 
   counter_t min_supp, char* input_file, counter_t nr_of_transactions, 
   std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters, 
   T_R& tr_reader, DF_D& df_decoder, typename S_C::params_t& par_c,
   TRIE_OEL& main_trie, FII& fii, unsigned int maxsize);
};

template <class TRIE_OEL, class TRIE_OI, class LEAF_WC, 
          class T_R, class DF_D, NEELevel NEE> 
AprioriSelector2<TRIE_OEL, TRIE_OI, LEAF_WC, T_R, DF_D, NEE>::
AprioriSelector2( 
   counter_t min_supp, char* input_file, counter_t nr_of_transactions, 
   std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters, 
   T_R& tr_reader, DF_D& df_decoder, TRIE_OEL& main_trie, 
   char *trcache_option, char* ordering_option, unsigned int maxsize)
{
   typedef bracz::singleualloc<LEAF_WC, 64 * 1024> LEAF_ALLOCATOR;
   typedef Bodon::dynamic_trie::FrequentPairInserter<DF_D, TRIE_OEL, 
      TRIE_OI, LEAF_WC, LEAF_ALLOCATOR, NEE> FPI;
   typedef Bodon::dynamic_trie::IntersectProPruner<
      DF_D, TRIE_OEL, TRIE_OI, LEAF_WC, LEAF_ALLOCATOR, NEE> PRUNER;
   typedef Bodon::dynamic_trie::CandidateGeneratorPrune<PRUNER, DF_D, 
      TRIE_OEL, TRIE_OI, LEAF_WC, LEAF_ALLOCATOR, NEE> CG;
   log_status(0,"Intersectpro pruning is selected.");
   typedef Bodon::dynamic_trie::FrequentItemInserter<DF_D, TRIE_OEL, NEE>
      FII;
   FII fii(main_trie, df_decoder);
   typedef Bodon::dynamic_trie::InfreqRemover<
      DF_D, TRIE_OEL, TRIE_OI, LEAF_WC, LEAF_ALLOCATOR, NEE> IR;
   if(strstr(trcache_option,"patricia"))
   {
      log_status(0,"Patricia caching option is on.");
      typedef Bodon::dynamic_trie::SupportCounter<TRIE_OEL, TRIE_OI> 
         SUPP_C_BASE;
      if(strstr(ordering_option, "ASC"))
      {
         log_status(0,"Ordering mode is ASC.");
         typedef SortedTransactionReader< 
            Coder<T_R, DF_D>, false, false > S_C_T_R;
         const bool ENDONLY = true;
         typedef OrderReverser< bracz::BuildTreeDBCache< 
            S_C_T_R, std::vector<item_t>, bracz::EndPatriciaBuildTree<
            ENDONLY>, ENDONLY > >S_C;
         typedef OneByOneSupportCounter<TRIE_OEL, S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
               
         typename S_C::params_t par_c;
         par_c.codemode = ASC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
      else
      {
         log_status(0,"Ordering mode is DESC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D>, false, true >
            S_C_T_R;
         const bool ENDONLY = true;
         typedef bracz::BuildTreeDBCache< 
            S_C_T_R, std::vector<item_t>, bracz::EndPatriciaBuildTree<
            ENDONLY>, ENDONLY > S_C;
         typedef OneByOneSupportCounter<TRIE_OEL, S_C, SUPP_C_BASE> 
            SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
         typename S_C::params_t par_c;
         par_c.codemode = DESC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);

      }
   }
   else if(strstr(trcache_option, "rb-tree-simul"))
   {
      log_status(0,"RB-tree caching with transaction filtering (simultaneous insert and delete) option is on.");
      typedef Bodon::dynamic_trie::SupportCounterFilter<TRIE_OEL, TRIE_OI> 
         SUPP_C_BASE;
      if(strstr(ordering_option, "ASC"))
      {
         log_status(0,"Ordering mode is ASC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheSimultaneous<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
               
         typename S_C::params_t par_c;
         par_c.codemode = ASC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
      else
      {
         log_status(0,"Ordering mode is DESC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheSimultaneous<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
       
         typename S_C::params_t par_c;
         par_c.codemode = DESC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
   }
   else if(strstr(trcache_option, "rb-tree-insert-clear-simple"))
   {
      log_status(0,"RB-tree caching with transaction filtering (with insert then clear, simple) option is on.");
      typedef Bodon::dynamic_trie::SupportCounterFilter<TRIE_OEL, TRIE_OI> 
         SUPP_C_BASE;
      if(strstr(ordering_option, "ASC"))
      {
         log_status(0,"Ordering mode is ASC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheInsertThenDestroySimple<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
               
         typename S_C::params_t par_c;
         par_c.codemode = ASC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
      else
      {
         log_status(0,"Ordering mode is DESC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheInsertThenDestroySimple<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
       
         typename S_C::params_t par_c;
         par_c.codemode = DESC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
   }
   else if(strstr(trcache_option, "rb-tree-insert-clear-pro"))
   {
      log_status(0,"RB-tree caching with transaction filtering (with insert then clear, pro) option is on.");
      typedef Bodon::dynamic_trie::SupportCounterFilter<TRIE_OEL, TRIE_OI> 
         SUPP_C_BASE;
      if(strstr(ordering_option, "ASC"))
      {
         log_status(0,"Ordering mode is ASC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheInsertThenDestroyPro<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
               
         typename S_C::params_t par_c;
         par_c.codemode = ASC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
      else
      {
         log_status(0,"Ordering mode is DESC.");
         typedef SortedTransactionReader< Coder<T_R, DF_D> > S_C_T_R;
         typedef Bodon::RBTreeDBCacheInsertThenDestroyPro<S_C_T_R> S_C;
         typedef OneByOneSupportCounterANDTransactionFiltering<TRIE_OEL, 
            S_C, SUPP_C_BASE> SUPP_C;
//             typedef Frequent2FilterOnline<S_C> F2F;
         typedef Frequent2Filter<S_C> F2F;
       
         typename S_C::params_t par_c;
         par_c.codemode = DESC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
   }
   else
   {
      log_status(0,"Transaction caching option is off.");
      typedef Bodon::dynamic_trie::SupportCounter<TRIE_OEL, TRIE_OI> 
         SUPP_C_BASE;
      typedef SortedTransactionReader<Coder<T_R, DF_D> >  S_C;
      typedef OneByOneSupportCounter<TRIE_OEL, S_C, SUPP_C_BASE> SUPP_C;
//          typedef Frequent2FilterOnline<S_C> F2F;
      typedef Frequent2Filter<S_C> F2F;
         
      typename S_C::params_t par_c;
      if(strstr(ordering_option, "ASC"))
      {
         log_status(0,"Ordering mode is ASC.");
         par_c.codemode = ASC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
      else
      {
         log_status(0,"Ordering mode is DESC.");
         par_c.codemode = DESC;
         StartApriori<S_C, SUPP_C, IR, FII, FPI, CG, LEAF_ALLOCATOR>(
            min_supp, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder, par_c, 
            main_trie, fii, maxsize);
      }
   }
}



template <class TRIE_OEL, class TRIE_OI, class LEAF_WC,
          class T_R, class DF_D, NEELevel NEE>  
template <class S_C, class SUPP_C, class IR, class FII, 
          class FPI, class CG, class LEAF_ALLOCATOR> 
void AprioriSelector2<TRIE_OEL, TRIE_OI, LEAF_WC, T_R, DF_D, NEE>::
StartApriori( counter_t min_supp, char* input_file,
              counter_t nr_of_transactions, 
              std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters, 
              T_R& tr_reader, DF_D& df_decoder, typename S_C::params_t& par_c, 
              TRIE_OEL& main_trie, FII& fii,  unsigned int maxsize )
{

   typedef Frequent2Filter<S_C> F2F;
   
   par_c.file_name = input_file;
   par_c.mode=FileReprBase::READ;
   par_c.largest_item = tr_reader.getLargestItem();
   par_c.decoder = &df_decoder;
   par_c.freq_items_with_counters = &freq_items_with_counters;
   log_status(0,"Doing sorted codec.");
   S_C sorted_coder(&par_c);
   std::vector< std::pair<counter_t, std::pair<item_t, item_t> > >
      freq_pairs_with_counters;
   F2F fr_2_filter(&sorted_coder );
   log_status(0,"Finding frequent pairs.")
      fr_2_filter.findFrequentPairs(freq_pairs_with_counters, 
                                    min_supp);         
   LEAF_ALLOCATOR s_alloc;
   IR infrequent_remover(main_trie, df_decoder, s_alloc);
   typedef Apriori<S_C, DF_D, TRIE_OEL, LEAF_ALLOCATOR, FII, 
      FPI, CG, IR, SUPP_C> A;
   A apriori(main_trie, s_alloc, infrequent_remover, sorted_coder, df_decoder, fii);
   log_status(0,"Finding frequent itemsets.");
   apriori.findFrequentItemsets( 
      nr_of_transactions, *par_c.freq_counters,
      freq_pairs_with_counters, min_supp, maxsize );
}

#endif

---