Introduction

This paper describes a preview version of the next generation of the EasyMiner system for interactive association rule learning and classification. EasyMiner consists of an interactive web-based user interface and a web-service layer, which wraps association rule learning implementation. The system was first introduced at ECML'12 [1] with the LISp-Miner (lispminer.vse.cz) system as the association rule learning backend. In this paper, we introduce a new version, which uses the popular arules package [2] for the R environment. In addition to association rule learning, the new release allows to perform classification based on association rules using the Classifications Based on Associations (CBA) algorithm [3].

The benefits of the new version are as follows. The arules package, implementing the apriori algorithm [4], provides better performance on larger datasets. The addition of the CBA algorithm allows for new use cases. Apart from the support for the classification task, CBA can be used as a rule pruning algorithm. Reducing the number of rules on the output is vital for many applications, including business rule learning [5].

This paper is organized as follows. Section 2 gives a walk through the system's user interface. Section 3 describes the backend. A brief description of the CBA component is given in Section 4. Evaluation of the system is covered by Section 5. The conclusions summarize the contribution and outline future work.

Workflow in the User Interface

As the first step, the user has to log in using local account or social networks. The user uploads the dataset in CSV or zipped CSV and selects mining backend (R or LISp-Miner). In the background this operation creates a named miner associated with a database table holding the raw data and an empty table holding the preprocessed data.

The user can optionally perform data preprocessing. This is especially needed for numerical attributes due to limitations of the apriori algorithm. The preprocessing is performed by the user dragging a field from the Data fields palette to the Attributes palette (Fig. 1A,B) and selecting preprocessing type (e.g. equidistant binning). This creates an attribute that can be used in the Rule pattern, out of a field in the input CSV file. In the background, the data are immediately processed. In order to facilitate processing of larger datasets, the system allows to skip the preprocessing step, using a verbatim copy of the fields in the input dataset as attributes.

In the main mining interface (Fig. 1), the user defines preprocessing instructions and the rule pattern. The definition is based on drag-and-drop operations the user drags an attribute from the attributes palette (Fig. 1B) and drops it into antecedent or consequent part of the rule pattern (Fig. 1C).

Finally, the user executes the task. This sends the task definition to the mining backend. The system supports ordering of the discovered rules (Fig. 1D) by values of interest measures. Selected rules can be stored in Rule Clipboard (Fig. 1E), the contents of which persists across multiple tasks on the same miner, or to the Knowledge Base, which persists across multiple miners.

The user interface layer is implemented in PHP (using Nette Framework) and JavaScript.

R backend

EasyMiner-Apriori-R is a REST service wrapper over the R arules library, which serves as a backend in EasyMiner, but can also be used as an independent web service.

This wrapper processes HTTP requests, transforms them to R scripts and forwards them to the R environment. The web service was implemented in the Scala language as a stand-alone application therefore it can be run on JVM (version 7+) without additional containers.

It provides the HTTP facade for sending association rule mining tasks in the GUHA AR PMML format, which is an extension of the PMML AssociationRules model3 that supports both standard association rules mined by apriori and more expressive GUHA rules mined by LISp-Miner, the original backend in EasyMiner. This PMML input is processed asynchronously and transformed to R scripts that use MySQL queries for data loading and itemset pruning, and the arules library for the association rules mining. Input data, which we want to mine association rules from, have to be saved in the MySQL database; so the PMML task input has to contain both information about a task (interest measure, antecedent and consequent definitions) and information about the connection to the database.

For the data transmission from the REST service to the R environment and vice versa we use the Rserve server. Any R script, sent to the R server, has to be completely initialized and all required libraries must be loaded for each request; this initializing part may take several seconds. In order to solve this problem we implemented an Rserve connection pooling system for the pre-initialization of R scripts, so if a user posts the mining task request to the server, the system is able to pull a prepared connection from the connection pool. The R apriori mining method is called immediately without waiting for an initialization. The result of the mining process is a PMML output file where found association rules are saved EasyMiner-Apriori-R is completely thread-safe and can handle several mining requests concurrently; the number of parallel connections depends on the actor system setting: the implementation uses Akka (http://akka.io) framework with Spray (http://spray.io).

Classification Based on Associations

CBA [3] is considered as the first algorithm for classification based on association rules. The algorithm was proposed in 1998, and it has multiple successor algorithms such as CPAR [6] or CMAR [7]. We selected the original algorithm rather than any of its successors, because it provides a desirable balance between accuracy and low rule count.

In general CBA proceeds as follows. The rules output by the apriori algorithm are sorted according to some criteria and then pruned -some rules are removed. Finally, a default rule is added at the bottom of the rule list ensuring that all instances will be covered. An unlabeled instance is classified by the top-ranked matching rule.

Since CBA only removes rules for the original list output by association rule learning, it can be also used for rule pruning. More compact rule sets have the advantage of better interpretability. The pruned rule set generated by CBA has the following desirable properties: a) each training case is covered by the rule with the highest precedence among the rules that can cover the case, and b) every rule correctly classifies at least one training case.

The CBA in EasyMiner/R follows the optimized M2 version of the algorithm [3]. Pessimistic pruning, an optional step in the original algorithm, is currently not included. The software is implemented in Java and wrapped with rJava into an R package. It is executed as an optional step within the R backend.

Evaluation

This section presents a comparison of the time requirements of EasyMiner/R with the previous version. We also empirically describe the effect of pruning on rule count and computation time.

Dataset. As the evaluation dataset we used the DBpedia Binary training dataset, generated from the ESWC 2014 Recommender Systems Challenge. 4This dataset contains 72,371 rows containing the following attributes: author (2 551 unique values), country (77 unique values), language (53 unique values), literaryGenre (307 unique values), mediaType (32 unique values), publisher (676 unique values) and rating (values 0 and 1). The dataset is very sparse with many missing values. No pre-processing was performed. The benchmark dataset is made available on the easyminer.eu website.

Task setting. The mining task was constrained so that the attribute rating is present in the consequent and the remaining attributes in the antecedent. The required minimal value of the confidence threshold was set to 0.5.

The count of discovered rules depends on missing value treatment. Columns denoted as with pruning contain the time requirements for solving the combined tasks of mining of association rules and the pruning using the CBA algorithm. Benchmark setup. We evaluate three configurations: a) the time required by the previous backend (LISp-Miner) run on desktop, b) the time required by the current backend (arules) run on desktop, c) the time required if mining is run from the frontend from the user interface in a web browser. This allows us to demonstrate improvement over the previous version as well as to show what additional latencies of gains have been introduced by EasyMiner/R compared to running the new arules backend system directly on the user's computer.

All three setups exclude the time required to preprocess the datasets and import them to a database.

The time reported for EasyMiner/R essentially amounts to: transmission of the task from user's browser to the front-end server, serialization of the task in the frontend-server to PMML, transmission to the server, execution of the mining task, serialization of results to PMML, transmission to the front-end server, display of the first ten rules in the user's browser. The result reported was measured in Firefox 38.0.1 (average across three runs).

Hardware and software configuration. The evaluation was performed using the latest version of LISp-Miner (25.14.06) run on Intel Core i7-3930K @ 3.2GHz, 3.5GB RAM.

Results. The results depicted at Table 1 show that EasyMiner with the arules package as the backend is significantly faster with lower support thresholds. An interesting observation is that for tasks with pruning set to off that produce a smaller number of rules, the user will even get the results faster with EasyMiner/R in than from the R console on her computer. This is due to a saving associated with the database connection pooling.

In case of tasks with pruning, the mining takes longer, but the resulting rule set is on this particular dataset up to nine times smaller, saving the time of the human analyst or computer system doing subsequent processing.

Conclusions and future work

EasyMiner/R available at http://easyminer.eu is an experimental academic system for association rule learning and building classifiers composed of association rules. The new version with R backend allows to handle larger datasets as empirically validated. Compared to the previous version using the LISp-Miner system, the new version does not allow to use expressive constructs such as disjunctions and negations when defining the rule pattern. Another limitation of the current version stemming from the use of the MySQL database is a limit on the maximum number of fields in the input dataset. We plan to remove the latter limitation in the next release, which will use a column-oriented database as the storage backend. Another much needed extension is execution of the benchmark on a representative sample of datasets.

EasyMiner/R is designed to be used as a complete integrated system, however, its individual components -the EasyMiner-Apriori-R5 web service wrapper for R arules package, and the CBA implementation6 , can also be used independently.