Introduction

One of the goals in the design of this package is to be able to integrate with the arules package. This means that any one using the arules functionalities can export to and import from fcaR objects, more precisely, FormalContext and ImplicationSet objects.

library(arules)
#> Loading required package: Matrix
#> 
#> Attaching package: 'arules'
#> The following objects are masked from 'package:base':
#> 
#>     abbreviate, write
library(fcaR)
#> 
#> Attaching package: 'fcaR'
#> The following object is masked from 'package:Matrix':
#> 
#>     %&%

Datasets

For these examples, we are using two binary datasets, Mushroom (from the arules package) and planets (from fcaR).

data("Mushroom", package = "arules")

At the moment, in arules there is no support for fuzzy sets, so we must restrict ourselves to the binary case.

Let us create a FormalContext object for the planets dataset:

fc_planets <- FormalContext$new(planets)

Converting between formal contexts and transactions objects

We begin by converting between the objects which store the datasets.

Importing a transactions object

It suffices to initialize a FormalContext object with the transactions dataset:

fc <- FormalContext$new(Mushroom)
fc
#> FormalContext with 8124 objects and 114 attributes.
#>     Class=edible  Class=poisonous  CapShape=bell  CapShape=conical  CapShape=flat  
#>   1                      X                                                         
#>   2       X                                                                        
#>   3       X                              X                                         
#>   4                      X                                                         
#>   5       X                                                                        
#>   6       X                                                                        
#>   7       X                              X                                         
#>   8       X                              X                                         
#>   9                      X                                                         
#>  10       X                              X                                         
#> Other attributes are: CapShape=knobbed, CapShape=sunken, CapShape=convex,
#> CapSurf=fibrous, CapSurf=grooves, CapSurf=smooth, ...

From this point, we can use all the functionalities in the fcaR package regarding formal contexts, concept lattices and implication sets.

Exporting a FormalContext

The to_transactions() function enables us to export a formal context to a format compatible with the arules package:

fc_planets$to_transactions()
#> transactions in sparse format with
#>  9 transactions (rows) and
#>  7 items (columns)

and use the functionality in that package.

Converting between implication sets and rules objects

Other point of integration between the two packages is the ability to import rules from the arules package, operate on them to compute closures, recommendations or to remove redundancies, or to export an implication set as a rules object.

Importing rules as an implication set

Let us suppose that we have extracted implications from the Mushroom dataset using the apriori() function:

mushroom_rules <- apriori(Mushroom, parameter = list(conf = 1), control = list(verbose = FALSE))

Once we have created the fc object storing the Mushroom dataset, we simply add the implications to it as:

fc$implications$add(mushroom_rules)

And we can use all the functionalities for the ImplicationSet class.

Exporting ImplicationSets to rules format

If we want to export the implications extracted for a binary formal context, we can use:

fc_planets$find_implications()
fc_planets$implications$to_arules(quality = TRUE)
#> set of 10 rules

Final considerations

An example of use may be to extract rules in the arules package by using apriori() or eclat(), then importing everything into fcaR as described above, and use the functionalities to simplify, remove redundancies, compute closures, etc., as needed, and then re-export back to arules.

Integration with the arules package