ruleInduction             package:arules             R Documentation

_R_u_l_e _I_n_d_u_c_t_i_o_n _f_o_r _a _S_e_t _o_f _I_t_e_m_s_e_t_s

_D_e_s_c_r_i_p_t_i_o_n:

     Provides the generic function and the needed S4 method to induce
     all rules which can be generated by the given itemsets from a
     transactions data set.

_U_s_a_g_e:

     ruleInduction(x, ...)
     ## S4 method for signature 'itemsets':
     ruleInduction(x, transactions, confidence = 0.8, 
         control = NULL)

_A_r_g_u_m_e_n_t_s:

       x: the set of itemsets from which rules will be induced. 

     ...: further arguments. 

transactions: the transaction data set used to mine  the itemsets. 

confidence: a numeric value giving the minimum confidence for the
          rules. 

 control: a named list with elements 'method' indicating the method
          ('"apriori"' or '"ptree"'), and the logical arguments
          'reduce' and 'verbose' to indicate if unused items are
          removed and if the output should be verbose. Currently, 
          '"ptree"' is the default method.

_D_e_t_a_i_l_s:

     If in control 'method = "apriori"' is used, a very simple rule
     induction method is used. All rules are mined from the
     transactions data set using Apriori with the minimal support found
     in itemsets. And in a second step all rules which do not stem from
     one of the itemsets are removed. This procedure will be in many
     cases very slow (e.g., for itemsets with many elements or very low
     support).

     If in control 'method = "ptree"' is used, the transactions are
     counted into a prefix tree and then the rules are selectively
     generated using the counts in the tree. This is usually faster
     than the above approach.

     If in control 'reduce = TRUE' is used, unused items are removed
     from the data before creating rules. This might be slower for
     large transaction data sets. However, if 'method = "ptree"' this
     is highly recommended as the items are further reorderd to reduce
     the counting time.

     If argument 'transactions' is missing it is assumed that 'x'
     contains a lattice (complete set) of frequent itemsets together
     with  their support counts. Then rules can be induced directly
     without  support counting. This approach is very fast.

_V_a_l_u_e:

     An object of class 'rules'.

_S_e_e _A_l_s_o:

     'itemsets-class', 'rules-class' 'transactions-class'

_E_x_a_m_p_l_e_s:

     data("Adult")

     ## find all closed frequent itemsets
     closed <- apriori(Adult, 
             parameter = list(target = "closed", support = 0.4))

     ## rule induction
     rules <- ruleInduction(closed, Adult, control = list(verbose = TRUE))

     ## inspect the resulting rules
     inspect(SORT(rules, by = "lift")[1:5])

     ## use lattice of frequent itemsets
     ec  <- eclat(Adult, parameter = list(support = 0.4))
     rec <- ruleInduction(ec)
     inspect(rec[1:5])

