tr_cache.cpp

Go to the documentation of this file.

#include "common.hpp"
#include "common/log.h"

#include "io/input/transaction_reader/brBufferedTransactionReader.hpp"

#include "io/codec/decoder/df/SimpleDFDecoder.hpp"
//#include "io/codec/decoder/df/CacheDFDecoder.hpp"
#include "io/codec/decoder/df/DFDecoderWithEEManagement.hpp"
//#include "io/output/StatOutput.hpp"
#include "io/output/normal/SortOutput.hpp"
//#include "io/codec/decoder/df/DFDecoderWrapper.hpp"

#include "util/StreamParser.hpp"
#include "util/FrequentFilter.cpp"

#include "datastructures/maxvector.hpp"
#include "datastructures/trie/edgelist/OrderedEdgelist.hpp"
//#include "datastructures/trie/edgelist/OrderedEdgelistDynLookup.hpp"
#include "datastructures/trie/edgelist/OffsetIndexVector.hpp"


#include "apriori/bodon/Leaf.hpp"
#include "apriori/bodon/Trie.hpp"
#include "apriori/bodon/TrieNEE.hpp"

#include "io/codec/coder/Coder.hpp"

#include "test/apriori/bodon/AprioriSelector2.hpp"

#include <vector>
#include <iostream>
#include <string>

std::string file_format;

void init()
{
   file_format = "File format:";
   file_format += "\n\nThe transactionfile is a plan text file. Each row ";
   file_format += "represents a transaction. ";
   file_format += "A transaction is a set of items seperated by a nonnumeric ";
   file_format += "character.\nIt can be for example a white space, comma, ";
   file_format += "colon, etc.\n";
   file_format += "Items are nonnegative integers.\n";
}
void usage()
{
   cerr<< "Usage: tr_cache tr_cache_option transactionfile min_supp outcomefile ordering_option nee_option [options]\n\n";
   cerr<<" tr_cache_option  option of transaction caching, \n\t\t  i.e: off, patricia, rb-tree-simul,";
   cerr<<" \n\t\t  rb-tree-insert-clear-simple, rb-tree-insert-clear-pro \n";
   cerr<<" transactionfile  file, that contains the tranasctions of items\n";
   cerr<<" min_supp\t  absolute support threshold\n";
   cerr<<" outcomefile\t  file to write the outcome\n";
   cerr<<" ordering_option  the ordering to be used, i.e: ASC, DESC\n";
   cerr<<" nee_option\t  equisupport pruning option, i.e: off, level3\n";

   std::cerr << file_format;
   cerr<<"\t\t\tHave a succesful mining ;-)\n\n";
}

int process_arguments( int argc, char *argv[], counter_t& min_supp, 
                       bool &isrel, double &relminsupp, unsigned int& maxsize )
{
   if ( argc < 7 )
   {
     log_err(0,"There are 6 mandatory arguments.");
     usage();
     return 2;
   }
   std::string mins=argv[3];
   if (mins[mins.size()-1]=='%') {
     mins.erase(mins.size()-1);
     isrel=true;
     relminsupp=atof(mins.c_str());
     relminsupp/=100;
     log_info(0,"Using relative minimum support of %lg",relminsupp);
     return 0;
   }
   isrel=false; relminsupp=0;
   int min_supp_i;
   try
   {
      convert(argv[3], min_supp_i);
      if ( min_supp_i <= 0  )
      {
         log_err(0,"%s cannot be converted to a positive integer.",argv[3]);
         return 3;
      }
   }
   catch(BadConversion e)
   {
      log_err(0,"min_supp conversion problem.");
      return 3;
   }
   min_supp = static_cast<counter_t>(min_supp_i);
   log_info(0,"min_supp is set to %d", min_supp);
   if(argc == 8)
   {
      int maxsize_i;
      try
      {
         convert(argv[7], maxsize_i);
         if ( maxsize_i <= 0  )
         {
            log_err(0,"%s cannot be converted to a positive integer.",argv[6]);
            return 4;
         }
      }
      catch(BadConversion e)
      {
         log_err(0,"max_size conversion problem.");
         return 4;
      }
      maxsize = static_cast<unsigned int>(maxsize_i);
      log_status(0,"maxsize is set to %d", maxsize);
   }
   else
      maxsize = largest_itemsetsize;
   return 0;
}

int main( int argc, char *argv[] )
{
   init();
   counter_t min_supp;
   unsigned int maxsize;
   bool relative;
   double relminsupp;
      
   {
      int return_val = 
         process_arguments( argc, argv, min_supp, 
                            relative, relminsupp, maxsize );
      if(return_val)
         return return_val;
   }

   char *trcache_option=argv[1];
   char* input_file = argv[2];
   char* output_file = argv[4];
   char* ordering_option = argv[5];
   char* nee_option = argv[6];

   try
   {
      // We assume that the transactions does not contain duplicates!!!
      typedef brBufferedTransactionReader< > T_R;
      // Otherwise uncomment this:
      // typedef SortedTransactionReader<brBufferedTransactionReader< >, true> T_R;

      T_R::params_t par_i;
      par_i.file_name = input_file;
      par_i.mode=FileReprBase::READ;
      par_i.file_buffer_size = 16 * 1024;
      T_R tr_reader(&par_i);
      std::vector< std::pair<counter_t, item_t> > freq_items_with_counters;
      counter_t nr_of_transactions;
      // The first step of each algorithms is determining the frequent items.
      FrequentFilter<T_R>
         fr_filter(tr_reader);
      log_status(0,"Finding frequent items.");
      fr_filter.findFrequentItems( freq_items_with_counters,  
                                   nr_of_transactions, min_supp);

      if(!freq_items_with_counters.empty())
      {
         log_status(0,"Doing decoder.");
         typedef DFDecoderWithEEManagement< > DF_D;
         DF_D::params_t par_d;
         par_d.file_name = output_file;
         par_d.mode=FileReprBase::WRITE;
//          par_d.numfreq = freq_items_with_counters.size(); // If StatOutput is used!!!
         DF_D df_decoder(&par_d);

         log_status(0,"APRIORI is selected");
         log_status(0,"deadend pruning option is on.");
         typedef Bodon::LeafWithoutConstructor LEAF_WC;  
         typedef Bodon::Leaf LEAF;       

         typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelist<std::vector<Edge> > > TRIE_OEL;
         typedef Bodon::Trie< LEAF, Bodon::OffsetIndexVector< std::vector<void*> > > TRIE_OI;

         if(strstr( nee_option,"off"))
         {
            const NEELevel NEE = NEE_Off;                
            log_status(0,"Equisupport pruning is disabled");
            TRIE_OEL main_trie;
            AprioriSelector2<TRIE_OEL, TRIE_OI, LEAF_WC, T_R, DF_D, NEE>(
               min_supp, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder,
               main_trie, trcache_option, ordering_option, maxsize);
         }
         else
         {
            const NEELevel NEE = NEE_Full;               
            log_status(0,"Level 3 equisupport pruning is enabled");
            typedef Bodon::TrieNEE<TRIE_OEL> TRIENEE_OEL;
            typedef Bodon::TrieNEE<TRIE_OI> TRIENEE_OI;
            TRIENEE_OEL main_trie;
            AprioriSelector2<TRIENEE_OEL, TRIENEE_OI, LEAF_WC, T_R, DF_D, NEE>(
               min_supp, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder,
               main_trie, trcache_option, ordering_option, maxsize);
         }
      }
   }
   catch (std::ios_base::failure e)
   {
      log_err(0,"Exiting the program due to IO exception");
      return 1;
   }
}

---