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)

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
#> Warning: Too many attributes, output will be truncated.
#> FormalContext with 8124 objects and 114 attributes.
#> Attributes' names are: Class=edible, Class=poisonous, CapShape=bell,
#>   CapShape=conical, CapShape=flat, CapShape=knobbed, ...
#> Matrix:
#>   Class=edible Class=poisonous CapShape=bell CapShape=conical CapShape=flat
#> 1            0               1             0                0             0
#> 2            1               0             0                0             0
#> 3            1               0             1                0             0
#> 4            0               1             0                0             0
#> 5            1               0             0                0             0
#> 6            1               0             0                0             0
#>   CapShape=knobbed CapShape=sunken
#> 1                0               0
#> 2                0               0
#> 3                0               0
#> 4                0               0
#> 5                0               0
#> 6                0               0

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))
#> Apriori
#> 
#> Parameter specification:
#>  confidence minval smax arem  aval originalSupport maxtime support minlen
#>           1    0.1    1 none FALSE            TRUE       5     0.1      1
#>  maxlen target  ext
#>      10  rules TRUE
#> 
#> Algorithmic control:
#>  filter tree heap memopt load sort verbose
#>     0.1 TRUE TRUE  FALSE TRUE    2    TRUE
#> 
#> Absolute minimum support count: 812 
#> 
#> set item appearances ...[0 item(s)] done [0.00s].
#> set transactions ...[114 item(s), 8124 transaction(s)] done [0.01s].
#> sorting and recoding items ... [53 item(s)] done [0.00s].
#> creating transaction tree ... done [0.01s].
#> checking subsets of size 1 2 3 4 5 6 7 8 9 10
#> Warning in apriori(Mushroom, parameter = list(conf = 1)): Mining stopped (maxlen
#> reached). Only patterns up to a length of 10 returned!
#>  done [3.80s].
#> writing ... [1799427 rule(s)] done [0.35s].
#> creating S4 object  ... done [1.23s].

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