TL;DR
This paper introduces a novel MDL-based approach for learning compact, interpretable probabilistic rule lists for multiclass classification, effectively balancing model complexity and accuracy without extensive hyperparameter tuning.
Contribution
The paper proposes a new formalization using MDL for probabilistic rule lists and introduces the Classy algorithm for efficient, parameter-insensitive model learning.
Findings
Classy produces small, accurate rule lists that outperform state-of-the-art classifiers.
The method is insensitive to the candidate set parameter.
Training set compression correlates with classification performance.
Abstract
Interpretable classifiers have recently witnessed an increase in attention from the data mining community because they are inherently easier to understand and explain than their more complex counterparts. Examples of interpretable classification models include decision trees, rule sets, and rule lists. Learning such models often involves optimizing hyperparameters, which typically requires substantial amounts of data and may result in relatively large models. In this paper, we consider the problem of learning compact yet accurate probabilistic rule lists for multiclass classification. Specifically, we propose a novel formalization based on probabilistic rule lists and the minimum description length (MDL) principle. This results in virtually parameter-free model selection that naturally allows to trade-off model complexity with goodness of fit, by which overfitting and the need for…
| Symbol | Definition | |
|---|---|---|
| Dataset of examples | ||
| Subset of where pattern occurs | ||
| Subset of where class label occurs | ||
| Subset of where and both occur | ||
| Total number of examples/instances | ||
| Dataset of instances of (without class labels) | ||
| Set of all Boolean variables in | ||
| Total number of Boolean variables in | ||
| Set of all possible binary vectors of size | ||
| Instance | ||
| Boolean variable | ||
| Vector of class labels in | ||
| Set of all class labels in | ||
| Total number of class labels in | ||
| Class label | ||
| Set of all proabilistic rule lists | ||
| Proabilistic rule list | ||
| Number of rules in (excluding the default rule) | ||
| rule of | ||
| Pattern/rule antecedent of | ||
| Number of logical conditions in pattern | ||
| Number of instances where occurs | ||
| Usage of given | ||
| Usage of where class also occurs given | ||
| Vector of probabilities of each class label of | ||
| Probability of the rule for class |
| Dataset | ||||
|---|---|---|---|---|
| hepatitis | ||||
| ionosphere | ||||
| horsecolic | ||||
| cylBands | ||||
| breast | ||||
| pima | ||||
| tictactoe | ||||
| mushroom | ||||
| adult | ||||
| iris | ||||
| wine | ||||
| waveform | ||||
| heart | ||||
| pageblocks | ||||
| led7 | ||||
| pendigits | ||||
| chessbig |
| Accuracy | Balanced accuracy | AUC | |||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| datasets | Classy | SBRL | JRip | CART | C5.0 | FURIA | SVM | Classy | BRL | JRip | CART | C5.0 | FURIA | SVM | Classy | BRL | JRip | CART | C5.0 | FURIA | SVM | ||
| hepatitis | |||||||||||||||||||||||
| ionosphere | |||||||||||||||||||||||
| horsecolic | |||||||||||||||||||||||
| cylBands | |||||||||||||||||||||||
| breast | |||||||||||||||||||||||
| pima | |||||||||||||||||||||||
| tictactoe | |||||||||||||||||||||||
| mushroom | |||||||||||||||||||||||
| adult | |||||||||||||||||||||||
| rank | |||||||||||||||||||||||
| iris | |||||||||||||||||||||||
| wine | |||||||||||||||||||||||
| waveform | |||||||||||||||||||||||
| heart | |||||||||||||||||||||||
| pageblocs | |||||||||||||||||||||||
| led7 | |||||||||||||||||||||||
| pendigits | |||||||||||||||||||||||
| chessbig | |||||||||||||||||||||||
| rank | |||||||||||||||||||||||
| AUC | Number of rules | Number of conditions | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| datasets | Classy | SBRL | JRip | CART | C5.0 | FURIA | Classy | SBRL | JRip | CART | C5.0 | FURIA | Classy | SBRL | JRip | CART | C5.0 | FURIA | ||
| hepatitis | ||||||||||||||||||||
| ionosphere | ||||||||||||||||||||
| horsecolic | ||||||||||||||||||||
| cylBands | ||||||||||||||||||||
| breast | ||||||||||||||||||||
| pima | ||||||||||||||||||||
| tictactoe | ||||||||||||||||||||
| mushroom | ||||||||||||||||||||
| adult | ||||||||||||||||||||
| rank | ||||||||||||||||||||
| iris | ||||||||||||||||||||
| wine | ||||||||||||||||||||
| waveform | ||||||||||||||||||||
| heart | ||||||||||||||||||||
| pageblocs | ||||||||||||||||||||
| led7 | ||||||||||||||||||||
| pendigits | ||||||||||||||||||||
| chessbig | ||||||||||||||||||||
| rank | ||||||||||||||||||||
| Difference tests | Holm’s post-hoc procedure (Classy as control) | ||||||||||||||||||||
| Friedman | a Iman and Davenport | SBRL | JRip | CART | C5.0 | FURIA | SVM | ||||||||||||||
| Measures | Classes | a | a | a | a | a | a | a | a | ||||||||||||
| Acc | binary | aR | aR | a | — | — | — | — | — | aR | |||||||||||
| multi | aR | aR | a | — | a | — | — | aR | a | aR | |||||||||||
| bAcc | binary | — | — | ||||||||||||||||||
| multi | aR | aR | — | — | — | — | aR | ||||||||||||||
| binary | aR | aR | — | — | — | — | — | aR | |||||||||||||
| multi | aR | aR | aR | — | — | — | — | ||||||||||||||
| binary | — | — | |||||||||||||||||||
| multi | aR | aR | aR | — | — | aR | |||||||||||||||
| Rules | binary | aR | aR | — | — | — | aR | ||||||||||||||
| multi | — | — | |||||||||||||||||||
| Conditions | binary | aR | aR | — | — | aR | a | aR | |||||||||||||
| multi | aR | aR | — | — | aR | ||||||||||||||||
| datasets | Classy | SBRL | JRip | CART | C5.0 | FURIA | SVM |
|---|---|---|---|---|---|---|---|
| hepatitis | |||||||
| ionosphere | |||||||
| horsecolic | |||||||
| cylBands | |||||||
| breast | |||||||
| pima | |||||||
| tictactoe | |||||||
| mushroom | |||||||
| adult | |||||||
| rank | |||||||
| iris | |||||||
| wine | |||||||
| waveform | |||||||
| heart | |||||||
| pageblocs | |||||||
| led7 | |||||||
| pendigits | |||||||
| chessbig | |||||||
| rank | |||||||
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Code & Models
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Abstract
Interpretable classifiers have recently witnessed an increase in attention from the data mining community because they are inherently easier to understand and explain than their more complex counterparts. Examples of interpretable classification models include decision trees, rule sets, and rule lists. Learning such models often involves optimizing hyperparameters, which typically requires substantial amounts of data and may result in relatively large models.
In this paper, we consider the problem of learning compact yet accurate probabilistic rule lists for multiclass classification. Specifically, we propose a novel formalization based on probabilistic rule lists and the minimum description length (MDL) principle. This results in virtually parameter-free model selection that naturally allows to trade-off model complexity with goodness of fit, by which overfitting and the need for hyperparameter tuning are effectively avoided. Finally, we introduce the Classy algorithm, which greedily finds rule lists according to the proposed criterion.
We empirically demonstrate that Classy selects small probabilistic rule lists that outperform state-of-the-art classifiers when it comes to the combination of predictive performance and interpretability. We show that Classy is insensitive to its only parameter, i.e., the candidate set, and that compression on the training set correlates with classification performance, validating our MDL-based selection criterion.
keywords:
Rule lists; Minimum Description Length principle; Interpretable models; Classification
1 Introduction
Interpretable machine learning has recently witnessed a strong increase in attention [12], both within and outside the scientific community, driven by the increased use of machine learning in industry and society. This is especially true for applications domains where decision making is crucial and requires transparency, such as in health care [28, 27] and societal problems [26, 47].
While it is of interest to investigate how existing ‘black-box’ machine learning models can be made transparent [36], the trend towards interpretability also offers opportunities for data mining, or Knowledge Discovery from Data (KDD), as this field traditionally has a stronger emphasis on intelligibility.
In recent years several interpretable approaches have been proposed for supervised learning tasks, such as classification and regression. Those include approaches based on prototype vector machines [33], generalized additive models [30], decisions sets [25, 44], and rule lists [28, 46]. Restricting our focus to classification, we make two important observations. First, we observe that state-of-the-art algorithms [25, 44, 28, 46, 3] are designed for binary classification; no interpretable methods specifically aimed at multiclass classification have been proposed, in spite of being a common scenario in practice. Multiclass classification is more challenging because of 1) the increased complexity in model search, due to the uncertain consequences of favouring one class over the others, and 2) the lack of possibilities to prune the search such as commonly used when finding, e.g., decision lists [3] or Bayesian rule lists [46] for binary classification. Our second observation is that although recent methods based on rules [28, 46] and decision sets [25, 44] have been shown to be effective, they tend to have 1) a fair number of hyperparameters that need to be fine-tuned, and 2) limited scalability. Especially the need for hyperparameter tuning can be problematic in practice, as it requires significant amounts of computation power and data (i.e., not all data can be used for training, as a substantial part has to be reserved for validation).
To address these shortcomings, we introduce a novel approach to finding interpretable, probabilistic multiclass classifiers that requires very few hyperparameters and results in compact yet accurate classifiers. In particular, we will show that our method naturally provides a desirable trade-off between model complexity and classification performance without the need for parameter tuning, which makes the application of our approach very straightforward and the resulting models both adequate classifiers and easy to interpret.
We will use probabilistic rule lists, as both the antecedent of a rule (i.e., a pattern) and its consequent (i.e., a probability distribution) are interpretable [28]. Using a probabilistic model has the additional advantage that one cannot only provide a crisp prediction, but also make a statement about the (un)certainty of that prediction.
We show that, given a set of ordered patterns, we can trivially estimate the corresponding consequent probability distributions from the data. The remaining question, then, is how to select a set of patterns that together define a probabilistic rule list that is accurate yet does not overfit. This is not only important to ensure generalizability beyond the observed data, but also to keep the models as compact as possible: larger models are harder to interpret by a human analyst [21]. Recent optimization [25] and Bayesian [46] approaches heavily rely on hyperparameters to achieve this, but those need to be tuned by the analyst and we specifically aim to avoid this.
The solution that we propose is based on the minimum description length (MDL) principle [38, 18], which has been successfully used to select small sets of patterns that summarize the data in the context of exploratory data mining [42, 41, 9]. The MDL principle can be paraphrased as “induction by compression” and roughly states that the best model is the one that best compresses the data. Advantages of the MDL principle include that it has solid theoretical foundations, avoids the need for hyperparameters, and automatically protects against overfitting by balancing model complexity with goodness of fit.
Our first main contribution is the formalization of the problem of selecting the optimal probabilistic rule list using the minimum description length principle. Although the MDL principle has been used for pattern-based classification before [42], we are the first to introduce a MDL-based problem formulation aimed at selecting rule lists for multiclass classification. Technically, our approach includes the use of the prequential plug-in code, a form of refined MDL that has only been used once in pattern-based modelling [9]. One advantage of our approach is that the resulting problem formulation is completely parameter-free.
Our second main contribution is Classy, a heuristic algorithm for finding good probabilistic rule lists. Inspired by the Krimp algorithm [42], we select a good set of rules from a set of candidate patterns. We empirically demonstrate, by means of a variety of experiments, that Classy outperforms RIPPER, C5.0, CART, and Scalable Bayesian Rule Lists (SBRL) [46] when it comes to the combination of classification performance and interpretability, in particular when taking into account that it has much fewer hyperparameters.
To illustrate this, Figure 1 shows an example rule list that was found using Classy on the zoo111http://archive.ics.uci.edu/ml/datasets/Zoo dataset, without any parameter tuning. Although it is not perfectly accurate, its accuracy () is pretty good considering that there are seven classes and the list only has four rules. Moreover, it provides probabilistic predictions and is very easy to interpret.
The remainder of this paper is organized as follows. First, Section 2 discusses related work, after which we introduce probabilistic rule lists and MDL for such lists in Sections 3 and 4, respectively. Section 5 presents the Classy algorithm. After that we continue with experiments in Section 6 and conclude in Section 7.
2 Related work
We start by comparing the most important features of our algorithm to those of state-of-the-art algorithms, and then provide a brief overview of the most relevant literature, grouped into three topics: 1) rule-based models; 2) similar approaches in pattern mining; and 3) MDL-based data mining. For an in-depth overview of interpretable machine learning, we refer to Molnar [32].
Table 1 compares the most important features of our proposed approach, called Classy, to those of other rule-based classifiers, which will be described in the next subsections. Classical methods, such as CART [7], C4.5 [35] and RIPPER [10], lack a global optimisation criterion and thus rely on heuristics and hyperparameters to deal with overfitting. Fuzzy rule-based models [2, 23], here represented by FURIA [20] use rule sets instead of rule lists and lack probabilistic predictions. Recent Bayesian methods [44, 25, 44] are limited to small numbers of candidate rules and binary classification, limiting their usability, and are here represented by SBRL [46] (which is representative for all of them). A recent approach also using MDL and probabilistic rule lists (MRL) [4] is aimed at describing rather than classifying and cannot deal with multiclass problems or a large number of candidates. Interpretable decision sets (IDS) [25] and certifiable optimal rules (CORELS) [3] use similar rules but do not provide probabilistic models or predictions.
Note that methods that explain black-box models [36, 37], typically denoted by the term explainable machine learning, also aim to make the decisions of classifiers interpretable. However, they mostly focus on sample-wise (local interpretation) explanations, while we focus on explaining the whole dataset (global interpretation) by means of a single model. As these goals lead to clearly different problem formulations and thus different results, it would not be meaningful to empirically compare our approach to explainable machine learning methods.
2.1 Rule-based models
Rule lists have long been successfully applied for classification; RIPPER is one of the best known algorithms [10]. Similarly, decision trees, which can easily be transformed to rule lists, have been used extensively; CART [7] and C4.5 [35] are probably the most best-known representatives. These early approaches represent highly greedy algorithms that use heuristic methods and pruning to find the ‘best’ models.
Fuzzy rules have been extensively studied in the context of classification and interpretability. Several approaches to construct fuzzy rule-based models have been proposed, such as transforming the resulting model of another algorithm into a fuzzy model and posteriorly optimizing it [20], using genetic algorithms to combine pre-mined fuzzy association rules [2], and doing a multiobjective search over accuracy and comprehensibility to find Pareto-optimal solutions [23]. Although these approaches are related, the rules are aggregated in a rule set, i.e., a set of independent if rules that can be activated at the same time to classify one instance, contrary to one rule at the time for rules lists. This makes the comparison between both types of models difficult. Also, these fuzzy rule-based models do not provide probabilistic predictions.
Over the past years, rule learning methods that go beyond greedy approaches have been developed, i.e., by means of probabilistic logic programming for independent rule-like models [5], greedy optimization of submodular problem formulation or simulated annealing in the case of decision sets [25, 44], by Monte-Carlo search for Bayesian rule lists [28, 46], and through branch-and-bound with tight bounds for decision lists [3]. Even though in theory these approaches could be easily extended to the multiclass scenario, in practice their algorithms do not scale with the higher dimensionality that arises from the search in multiclass space with an optimality criteria. Also, only Bayesian rule lists [28, 46] and Bayesian decision sets [44] provide probabilistic predictions.
All previously mentioned algorithms share some similarities with Classy. In particular Bayesian rule lists [28, 46] are closely related as they use the same type of models, albeit with a different formulation, based on Bayesian statistics. This difference leads to different types of priors—for example, we use the universal code of integers [39]—and therefore to different results; we will empirically compare the two approaches. Certifiable optimal rules [3] have a similar rule structure but do not provide probabilistic models or predictions. Decision sets [25] share the use of rules, but as opposed to (ordered) lists they consider (unordered) sets of rules.
2.2 Pattern mining
Association rule mining [1], a form of pattern mining, is concerned with mining relationships between itemsets and a target item, e.g., a class. One of its key problems is that it suffers from the infamous pattern explosion, i.e., it tends to give enormous amounts of rules. Several classifiers based on association rule mining have been proposed. Best-known are probably CBA [31] and CMAR [29], but they tend to lack interpretability because they use large numbers of rules. Ensembles of association rules, such as Harmony [43] or classifiers based on emergent patterns [16], can increase classification performance when compared to the previous methods, however they can only offer local interpretations. Subgroup discovery and similar approaches [24] are all relevant too, but they focus on finding descriptive patterns and not on finding global classification models. Approaches to supervised pattern mining based on significance testing [45] do not focus on finding global models either.
A last class of related methods is that of supervised pattern set mining [49]. The key difference is that these methods do not automatically trade-off model complexity and classification accuracy, requiring the analyst to choose the number of patterns in advance.
2.3 MDL-based data mining
In data mining, the MDL principle has been used to summarize different types of data, e.g., transaction data [42, 9], and two-view data [40].
In prediction it has been previously used to deal with overfitting [10, 35] and in the selection of the best compressing pattern [48].
RIPPER and C4.5 [10, 35] use the MDL principles in their post-processing phase as a criteria for pruning, while we use it in a holistic way for model selection. Although Krimp has been used for classification [42], it was not designed for this: it outputs large pattern sets, one for each class, and does not give probabilistic predictions. DiffNorm [9] creates models for combinations of classes and also uses the prequential plug-in code, but was designed for data summarization. Aoga et al. recently also proposed to use probabilistic rule lists and MDL [4], but 1) we propose a vastly improved encoding, which is tailored towards prediction (instead of summarization), 2) our solution does multiclass classification, and 3) our algorithm has better scalability.
3 Multiclass classification with rule lists
In this section we formalize the probabilistic rule list model and show how to estimate its parameters, i.e., the rule consequent probabilities. The notation most commonly used throughout this paper is summarized in Table 2.
Let be a supervised Boolean dataset, i.e., a Boolean dataset with a (multi)class label vector . Note that any categorical dataset can be trivially represented as a Boolean dataset using dummy variables, hence our methods apply to any categorical dataset as well. Each example forms a pair , which consists of an instance of Boolean variables and a class label .
An instance consists of binary values, with the set of all Boolean variables in . That is, is an element of the set of all possible Boolean vectors of size , i.e, . A pattern is a logical conjunction of variable-value assignments over instance space , e.g., . A pattern occurs in instance , denoted , iff satisfies the predicate defined by pattern . Thus, in our example, the pattern occurs in an instance iff and ; the values of the other variables do not influence the occurrence of this pattern. A pattern is said to have size equal to the number of conditions it contains; in this case . Each class label is an element of the set of all classes, i.e., , where and is the number of classes in the dataset.
We consider the problem of multiclass classification. That is, given training data , the goal is to induce a classification model that accurately predicts class label for any (possibly unseen) instance .
3.1 Probabilistic rule lists
A probabilistic rule list (PRL) is an ordered list of rules ending with a default rule , where each defines a probability distribution over the class labels. Note that this means that has rules in total. Each rule consists of a pair , where a pattern is the antecedent and a categorical distribution (i.e., a generalized Bernoulli distribution) over the class labels is the consequent. Whenever clear from the context we use as shortcut for the parameters associated with pattern . Each categorical distribution is parameterized by individual class probabilities , such that and . That is, rule is given by
[TABLE]
The default rule , which intuitively corresponds to a rule with the empty set as antecedent, is associated with a categorical distribution over the class labels denoted by . An example PRL with rules is given by:
[TABLE]
Given a PRL , an instance is classified by going through the rule list top-down, i.e., is classified according to , which is defined as the first rule in the list for which occurs in (). If none of the patterns occurs in a given instance, the classifier automatically falls back to the default rule . From the pattern that is activated for a given instance, the user obtains a corresponding probability distribution over the class labels for instance . In case a crisp prediction is necessary, as for example when comparing a PRL with other classifiers, we follow the typical approach, which is to predict the class label that has the highest probability:
[TABLE]
Note that contrary to decision lists, which only provide an associated class per rule, probabilistic rule lists provide a distribution over all class labels. This provides the user with extra information about the classification that is made, in the form of a probability of seeing each class label for a certain instance. This is especially relevant in the multiclass scenario where crisp classification implies a choice between more than two classes.
3.2 Parameter estimation
In the previous section the PRL is assumed to be given, while in practice we want to learn its parameters from the data. We defer the problem of selecting the patterns to the next section and first describe how to estimate the parameters of the categorical distributions from data, i.e., how to estimate , for , given an (ordered) set of patterns.
We first introduce some notation. The support of a pattern is the number of times that the pattern occurs in (training) data :
[TABLE]
The usage of is the number of times it is activated in (training) data . That is, it is the support of minus the instances that were already covered by other patterns that come before in :
[TABLE]
For ease of presentation, we abbreviate as whenever and are clear from the context.
Next, we introduce class-specific usage as the number of times a pattern is activated on a training instance with class label . We define a class-conditioned dataset as
[TABLE]
and class-specific usage as
[TABLE]
Given the usages and class-specific usages, which are easy to compute, it is straightforward to define a maximum likelihood estimator for , for any rule and class . We use a variant that is called a smoothed maximum likelihood estimator:
[TABLE]
Unlike the regular maximum likelihood estimator, this smoothed variant—known as Laplace smoothing—adds a (small) pseudocount to each class-specific usage even when that class has no counts. This avoids zero probabilities for any class label and corresponds to using a symmetric Dirichlet prior for each class [17]. Note that this estimate could be interpreted as the confidence of the rule in a list, accounting for what has been covered by previous rules.
4 MDL for multiclass classification
Having defined our models and parameter estimator, the remaining question is how to select adequate models. As we are interested in finding compact yet accurate rule lists that do not overfit, we resort to the minimum description length (MDL) [38, 18] principle, which can be paraphrased as “induction through compression”. The problem of selecting a concrete rule list from a large space of possible rule lists is a point hypothesis selection problem, for which we should use a two-part code [18].
In contrast to existing pattern-based modeling approaches (e.g., [42, 41]), we deal with a supervised setting in which the goal is to learn a mapping from instances to class labels. This implies that we are not looking for structure within instance data , but for structure in that helps to predict .
That is, to induce a mapping from instances to class labels, we should consider the instance data to be given as ‘input’ to the (classification) model and only encode the class labels . Clearly, the models that we consider are the probabilistic rule lists that we introduced in the previous section. Then, given the complete space of models , uniquely specified by all ordered sets of patterns over , the optimal model is the model that minimizes
[TABLE]
where is the encoded length, in bits222To obtain lengths in bits, all logarithms in this paper are to the base 2., of the class labels given data and model , and is the encoded length, in bits, of the model. Equation (6) represents a trade-off between how well the model fits the data, and the complexity of that model, . Note that, on a high level, two-part code in (6) is similar to the one that was recently used in the context of two-view data [40], but there the goal was summarization rather than classification and the details of the encodings are very different. The next subsections describe the two parts of the encoding, together with examples of how to compute the length of the encodings in practice.
4.1 Model encoding
Following the rule of parsimony associated with the MDL principle [18], the model encoding should result in larger code lengths for more complex models. To accomplish this we use only two types of codes for the different model components, the universal code for integers and the uniform code.
The universal code for integers [39], also called the universal prior for integers, is given by , where and . This code makes no a priori assumption about the maximum number accepted by the model and a small assumption in terms of penalizing larger numbers, as it grows logarithmically with and thus slower than the number of data instances . This makes it quite different from the Poisson prior typically used in Bayesian approaches [46]: that prior more strongly penalizes integers that are further away from the expectation of the distribution, as defined by the user-chosen parameter. We use when we want to penalize the increase of elements in the model, such as the number of rules or the length of a pattern.
The uniform code avoids any bias by assigning code words of equal length to all elements and is therefore used when all elements are equal. E.g., to encode a variable from a set of variables: .
We will now show how to compute the total length of a model, i.e., a probabilistic rule list over the variable space :
[TABLE]
where first the number of rules is encoded using the universal code for integers, and then the individual patterns are encoded. The length of pattern is given by
[TABLE]
where the number of conditions in is encoded with the universal code for integers, and then each of its conditions are encoded with a uniform code over . Contrary to what is common in existing MDL-based pattern set mining approaches (e.g., [42, 9]), which are aimed at summarization, we do not use normalized supports for encoding our patterns. That is, previous work typically uses codes based on the support of a pattern of size (singleton), e.g., , and normalizes this support by the sum of all their supports. Although this works well for summarization, in classification higher support does not necessarily imply better predictive power; hence we use the uniform code. In general, without prior knowledge the uniform code represents the best, unbiased choice [18].
Example 1 (part 1 of 2): We use the example rule list in Figure 1 to show how to compute the length of the model encoding. The model contains rules plus a default one, condition per rule, over a dataset with binary variables. According to Equation (7) the length of the model encoding is:
[TABLE]
Note that for the purpose of model selection we are only concerned with the length of the encoding, not in materialised codes, hence the values should not be rounded to natural numbers.
4.2 Data encoding
For the encoding of the data we use the prequential plug-in code, because it is asymptotically optimal even without any prior knowledge on the probabilities [18]. Moreover, the prequential plug-in code directly uses and gives us the smoothed maximum likelihood estimates for , as defined in Subsection 3.2, which makes it a natural choice.
Intuitively, the idea of the prequential plug-in code is that one starts with a pseudocount for each possible element, constructs a code using these pseudocounts, starts encoding/sending/decoding messages one by one, and then updates the count of each element after sending/receiving each individual message.
We apply this idea to encode the class labels, . Ignoring the rule list for a moment, initially each class label has a pseudocount of . Hence, when sending the first class label, , we effectively use a uniform code, i.e., . After that, however, we increase the count of that class label by one. Normalizing the updated counts results in a new categorical probability distribution—hence a new code: . This code is the best possible code given the data seen so far and is equal to the smoothed maximum likelihood of Eq. (5). Formally, the plug-in code for encoding the class labels is defined as
[TABLE]
where represents the class label, represents the sequence of the first class labels, and is the pseudocount necessary for to be valid. Choosing the uniform prior, i.e., , is a common choice for categorical distributions [46], and we will use that value henceforth.
We now show how the probabilistic rule lists can be used in the encoding of the class labels. By definition, only one rule is activated for each instance, hence each rule only activates in a unique part (subset) of the dataset. By realizing that the encoding of an example in a subset only depends on the rule that formed that subset, the encoding of the dataset can be simplified to the sum of the encoding of its subsets. We define the part covered by a rule antecedent as
[TABLE]
Thus it is possible to define the encoding of the whole data as:
[TABLE]
Inserting the prequential plug-in code (9) in (10) we obtain:
[TABLE]
where is a sequence of class labels of length in part , and and are the usage and class-specific usage of pattern respectively. Further, is the gamma function, an extension of the factorial to real and complex numbers that is given by .
Even though the code was formulated for sequential data, the order in which the class labels are transmitted in i.i.d data does not affect the encoded length, as the probability distribution only depends on the usage of the patterns, not on the order, as can be seen in the last equation.
Example 1 (part 2 of 2): We continue our example of Figure 1 with the computation of the length of the data encoding. For this we use , as we will also use in our experiments. First, we show how to compute the length of encoding the part covered by rule using Equation (11):
[TABLE]
We repeat this step (not shown) for the other parts of the dataset, which are covered by rules and respectively. Summing the length of all five parts, following Equation (10), we obtain bits for the length of the data encoding given , i.e., .
Finally, we sum the results obtained for and (in the first part of this example), and obtain bits for the joint length of the data and model encoding, as defined by Equation (6).
5 The Classy algorithm
Given our model class—probabilistic rule lists—and its corresponding MDL formulation, what remains is to develop an algorithm that—given the training data—finds the best model according to our MDL criterion. To this end, in this sectio, we present Classy, a greedy search based algorithm that iteratively finds the best rules to add to a rule list. This section is structured as follows. First, a brief description of separate-and-conquer greedy search is given. Then compression gain, i.e., the measure that uses compression to score candidate rules, is described. After that, the Classy algorithm is defined. Then, it is explained how individual rules—candidates for the model—are generated from the data. Finally, we analyse Classy’s time and space complexity.
5.1 Separate-and-conquer greedy search
Greedy search is very commonly used for learning decision trees and rule lists [35, 10, 15], as well as for pattern-based modelling using the MDL principle [42, 9, 40]. A few recent approaches use optimization techniques [46], but these have the limitation that the search space must be strongly reduced, providing an exact solution to an approximate problem (as opposed to an approximate solution to an exact problem).
Global heuristics, such as evolutionary algorithms, have been extensively applied to fuzzy rule-based model learning [13], and although they could also be applied here, we found that the arguments in favor of a local search approach were stronger: 1) local heuristics have often been successfully applied for pattern-based modelling using the MDL principle, making it a natural approach to consider; 2) local heuristics are typically faster than global heuristics, as much fewer candidates need to be evaluated; 3) global heuristics typically require substantially more (hyper)parameters that need to be tuned (e.g., population size, selection and mutation operators, etc.), while local heuristics have very few.
Given the arguments presented here the algorithm that we propose is based on greedy search. More specifically, it is a heuristic algorithm that, starting from a rule list with just a default rule equal to the priors of the class labels in the data, adds rules according to the well-known separate-and-conquer strategy [15]: 1) iteratively find and add the rule that gives the largest change in compression; 2) remove the data covered by that rule; and 3) repeat steps 1-2 until compression cannot be improved. This implies that we always add rules at the end of the list, but before the default rule.
5.2 Compression gain
The proposed heuristic is based on the compression gain that is obtained by adding a rule to a rule list , which will be denoted by . We will argue—and demonstrate empirically later—that for the current task it is better to consider normalized gain rather than the typically used absolute gain. Note that the gains are defined positive if adding a rule represents a compression improvement, and negative vice-versa.
Absolute compression gain, denoted , is defined as the difference in code length before and after adding a rule to . The gain can be divided in two parts: data gain, , and model gain, . Together this gives
[TABLE]
Using Eq. (7) we show absolute gain as:
[TABLE]
Note that model gain is always negative, as adding a rule adds additional complexity to the model.
In the case of the data gain it should be noted that adding rule to only activates the part of the data previously covered by the default rule, as new rules are only added after the previous ones and before the default rule. This search strategy of adding rules assumes that the previous rules already cover their subset well, and that improvements only need to be made where no rule is activated, which corresponds to the region of the dataset covered by the default rule. Hence, we only need to compute the difference in length of using the previous default rule and the combination of the new pattern with the new default rule . Using Equation (10) we obtain
[TABLE]
Normalized compression gain, denoted , is defined as the absolute gain normalized by the number of instances that are activated by pattern , which can be obtained by dividing absolute gain by the usage of :
[TABLE]
By normalizing for the number of instances that a rule covers, normalized gain favors rules that cover fewer instances but provide more accurate predictions compared to absolute gain. When greedily covering the data, it is essential to prevent choosing large but moderately accurate rules in an early stage; this is likely to lead to local optima in the search space, from which it could be hard to escape. As this is bound to happen when using absolute gain, our hypothesis is that normalized gain will lead to better rule lists. We will empirically verify if this is indeed the case.
5.3 Candidate generation
Candidates are probabilistic rules of the form that are considered for addition to a rule list for a dataset . The candidates are generated by first mining a rule antecedent/pattern using a standard frequent pattern mining algorithm, e.g., FP-growth [6], and then finding the corresponding consequent categorical distribution given the dataset, i.e., using Equation (5). In practice these mining algorithms have only two parameters: the minimum support threshold and the maximum length of a pattern. Mining frequent patterns can be done efficiently due to the anti-monotone property of their support, i.e., given a pattern and , if has less conditions then , i.e., , implies that . This property is also used to remove strictly redundant rules in Classy. Given all candidates from the frequent pattern mining algorithm, if the antecedent is a strict subset of antecedent , i.e., , and they have equal support, , we say that antecedent is redundant and will never be selected. This is a consequence of their encoding, i.e., in the case they are being considered for the same position, and that the model encoding length of will always be larger than , i.e., . From this we can conclude that will never be preferred over during model search, as the gain of will always be greater.
5.4 Finding good rule lists
We are now ready to introduce Classy, a greedy algorithm for finding good solutions to the MDL-based multiclass classification problem as formalized in Section 4. The algorithm, outlined in Algorithm 1, expects as input a (supervised) training dataset and a set of candidate patterns, e.g., a set of frequent itemsets mined from , and returns a probabilistic rule list.
The first step of our algorithm, line 3 is to remove the strictly redundant patterns as mentioned in Section 5.3. After that, in line 4 we initialize the rule list with the default rule, which acts as the baseline model to start from. Then, while there is a rule that improves compression (Ln 9), we keep iterating over three steps: 1) we select the best rule to add (Ln 6)—we here use normalized gain for ease of presentation, but this can be trivially replaced by absolute gain; 2) we add it to the rule list (Ln 7); and 3) we update the usage, and gain of the candidate list (Ln 8). To update the usage of a candidate it is necessary to remove from its usage the instances that it has in common with the previous added rule, and then the gain of adding the candidate can be updated. When there is no rule that improves compression (negative gain) the while loop stops and the rule list is returned.
5.5 Complexity
In this section we analyze the time and space complexity of Classy. In terms of time complexity, Classy can be divided in two parts: 1) an initialization step, and 2) an iterative loop where one rule is added to a PRL in each iteration.
The time complexity of the initialization step is dominated by sorting the candidates (ascending by length) obtained after running the frequent pattern mining algorithm, and the computation of their instance ids, i.e., the indexes of the instances where each candidate is present. Sorting all candidates takes time. To compute the instance ids of the candidates, Classy first computes the presence of each singleton condition, i.e., is tested for each variable, in each instance, and then stores them as a bitset in a hash table. As this is done for the whole dataset, it takes time. Then, for candidates of size equal or greater than two and given a sorted array of candidates, it sequentially computes the instance ids of each candidate based on its decomposition in two candidates of one less condition, i.e., it computes the ids of based on two candidates and for which of length . The ids of are obtained by the intersection of the sets of instance ids of the smaller length candidates and has a complexity of . As this is done for each class and in a worst case it would cover the whole dataset, it takes . Doing this for all candidates gives .
After the initialization step Classy iteratively finds the best rule to add for a total of runs, where is the PRL that Classy outputs at the end. The time complexity of this loop is dominated by the removal of the instance ids that all candidates have in common with the last added rule. Using again the fact that the intersection of instance ids is upper bounded by the dataset size , the removal of instance ids takes at most time. Given that the rule list can grow at most to the size of the dataset, an upper bound on this complexity is . Joining everything together, Classy has a worst case time complexity of
[TABLE]
which is really a worst case scenario, because in general MDL will obtain PRLs that are much smaller than the dataset size, i.e., , making it possible to treat it as a constant. Making this assumption we obtain a more realistic worst case time complexity of
[TABLE]
Note that the time complexity associated with the Gamma function used in the computation of lengths (10) and gains (15) of data encoding is not problematic when compared with the other terms. This is due to its recursive computation for values, which can be stored in a dictionary. In total this takes time, where is the complexity of the used multiplication; in the case of our Python implementation this is the Katsuraba multiplication. From then on, the lookup of a value only takes time.
In terms of memory complexity, Classy has to store for each candidate for each class: their instance ids , their support , and their score . It is easy to see that is upper bounded by the dataset size and that all other memory requirements will be dominated by this part. Also, the storage of the gamma function for each integer up to is only , which gets dwarfed by the instance storage, thus obtaining a worst case memory complexity of
[TABLE]
6 Experiments
In this section we empirically evaluate our approach333Implementation available on https://github.com/HMProenca/MDLRuleLists, first in terms of its sensitivity to the candidate set provided and the relationship between compression and classification performance, and second in comparison to a set of representative, state-of-the-art baselines in terms of classification performance, interpretability, overfitting, and runtime.
Data. We use varied datasets (see Table 3) from the LUCS/KDD444http://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/dataSets.html repository, all of which are commonly used in classification papers. They were selected to be diverse, ranging from to samples, from to Boolean variables, and from to classes.
Candidates. Frequent pattern mining algorithms generate different candidate sets by setting different values for the minimum support per class threshold and maximum pattern length . To demonstrate that Classy is insensitive to the exact settings of these parameters, we fix a single set of parameter values for all experiments on all datasets (except when we investigate the influence of the candidate set). Specifically, we use and , to obtain a desirable trade-off between candidate set size, convergence, and runtime.
These values were objectively derived based on two criteria: making each run finish within minutes while demonstrating that Classy can deal with large candidate set sizes. First we chose because this potentially results in very large candidate sets with many redundant rules (i.e., rules that are very similar / strongly overlapping). We then fixed by requiring the runs for all datasets to strictly finish in under minutes and for most datasets even under minute, so as to be comparable to , and in runtime, and also to have attained (empirical) convergence in terms of compression ratio on the training set—further lowering would not increase compression—as can be seen from the vertical dashed lines in Figure 7c.
Candidate patterns are mined using Borgelt’s implementation of the well-known frequent pattern mining algorithm FP-growth [6]. The same candidate set was used for all experiments except when assessing its influence on Classy in Section 6.2. For that experiment we fixed and varied the minimum support threshold per class from .
Evaluation criteria. We evaluate and compare our approach based on classification performance, overfitting, interpretability, and runtime. In addition, we assess the influence of the candidate set on our algorithm and whether better compression corresponds to better classification. All results presented are averages obtained using times repeated -fold cross-validation (with different seeds).
To quantify how well a rule list compresses the class labels, we define relative compression as
[TABLE]
where is the compressed size of the data given the rule list with only a default rule, i.e., with only the dataset priors for each class. We measure relative compression on the training data, as we use that for model selection.
Classification performance is measured using three measures: accuracy: balanced accuracy [8]; and Area Under the ROC Curve (AUC). Each measure portrays different aspects of the classifier performance. Accuracy shows the total number of correct classifications. Balanced accuracy, or averaged class accuracy, takes into account the imbalance of class distributions in the dataset and gives the same importance to each class. It is obtained by averaging the recall associated with each class label; informally:
[TABLE]
AUC, on the other hand, is not based on a fixed threshold and takes into account the probabilities associated with each prediction. In case of multiclass datasets we use weighted AUC [34], as it takes into account the class distribution in the dataset. Weighted AUC is obtained by weighing per-class ‘binary’ AUCs (one-versus-all) with the marginal class frequencies:
[TABLE]
where is the one-versus-all AUC for class label and is the frequency of that same class label.
For interpretability we follow the most commonly used interpretation, i.e., that smaller models are easier to understand [12]. With this in mind, we assess: the number of rules and the number of conditions per rule; in all cases, fewer is better. When analyzing decision trees, the number of leaves is given as the number of rules (which includes the default rule), and the average depth of the leaves (except for the longest—assumed the default rule) is given as the number of conditions per rule. Although rule lists derived from decision trees can often be simplified, we here choose not to do this because these directly measures how it would be read by humans.
Overfitting is measured in terms of the absolute difference between the AUC performance in the training set and in the test set. Finally, for runtime, wall clock time in minutes is measured; no parallelization was used.
Note on standard deviations. Given that the number of values reported both in figures and tables is large, and that standard deviations are usually orders of magnitude smaller than their corresponding averages, we choose not to report them—to avoid unnecessarily cluttering the presentation. We did analyse them though and explicitly comment on the few cases where relevant.
6.1 Compression versus classification
We first investigate the effect of using absolute (12) or normalized gain (15). To this end Figure 2 depicts how the two heuristics perform with respect to relative compression (on the training set) and AUC (on the test set).
The first observation is that better compression of the training data clearly corresponds to better classification performance on the test data. This is backed by a correlation of and a corresponding p-value lower than for the independence test between both variables for the normalized gain data. This is a crucial observation, as it constitutes an independent, empirical validation of using the MDL principle for rule list selection. Moreover, it also shows that MDL successfully protects against overfitting: using normalized gain leads to models that not only compress the training data better, but also provides accurate predictions on the test data.
The second observation is that normalized gain performs better overall than absolute gain: AUC is higher in out of cases and relative compression is lower or equal in out of times. This confirms that normalized gain is, as we hypothesized, the best choice. We will therefore use normalized gain for the remaining experiments.
6.2 Candidate set influence
In this set of experiments we study the influence of the candidate set on Classy, which technically is its only “parameter”, as it is the only part that can influence its output given the same dataset. In order to vary the candidate set objectively, the minimum support threshold ranges over and the maximum pattern length was fixed at , allowing the generation of large candidate sets.
The results can be seen in the set of Figures 7, which show the influence of the candidate set on Classy through: the size of candidates mined in Figure 3(a); runtime in Figure 4(a); compression on the training set in Figure 5(a); AUC in the test set in Figure 6(a); and the number of rules in a rule list in Figure 7(a).
Figure 3(a) shows the growth of of the candidate set size with the minimum support threshold used, and that, as expected, its growth is exponential with the change in minimum support. Figure 4(a) shows that in general the runtime increases at a rate similar to the increase in candidate size of figure 3(a). This is in accordance with our analysis of time complexity in Section 5.5, which tells us that the time complexity of Classy grows proportionally to the dataset size times the candidate set size, thus, given a fixed dataset size it becomes proportional only to the candidate set size.
Figures 5(a) and 6(a) show how Classy performs in classification in terms of compression in the training set and AUC in the test set, respectively. The values for both plots remain constant for most cases, and when a value deteriorates in terms of compression (increase in compression ratio) for smaller candidate sets, it also deteriorates accordingly in terms of AUC (decrease in AUC) in the test set. We make two important observations: 1) the minimum in compression is achieved at the minimum support used for out of datasets, and in the cases where it does not happen the difference in relative compression is below , which tells us that Classy can find a good description of the data using large candidate sets, without too greedily using rules that only cover few instances; 2) the minimum in compression and maximum in AUC are achieved for the same support value for out cases, and in the other cases, the difference is usually smaller than in both measures, revealing the robustness of our MDL formulation at obtaining models that generalize well. The main exception is ionosphere, where the best AUC is found at the minimum support threshold of , while the lowest threshold finds a PRL with lower AUC, without almost any change in compression. This can be explained by the relatively small number of examples of ionosphere ( instances) combined with its peculiar structure.
Figure 7(a) shows the number of rules selected based on the candidate set. As expected the number of rules selected only decreases or remains constant with the candidate set, except for mushroom. Upon closer inspection, we observe that this is due to the disappearance of a rule with good performance but low coverage from the candidate set, which has to be replaced by a combination of other rules. The cases where many more rules are selected for lower minimum support thresholds, such as chessbig and adult, have lower compression and higher AUC values for these large number of rules, which makes these selections sustainable.
6.3 Classification performance
We now compare the classification performance of Classy to Scalable Bayesian Rule Lists (SBRL) [46], JRip555 https://cran.r-project.org/package=RWeka, FURIA5, CART666https://cran.r-project.org/package=rpart, C5.0777https://cran.r-project.org/package=C50, and Support Vector Machines888https://cran.r-project.org/package=e1071 (SVM). These methods are state-of-the-art classifiers, and SBRL, CART, C5.0, JRip, and FURIA—a fuzzy unordered rule induction algorithm—are clearly related to our approach. C5.0 is a newer version of C4.5, and JRip is a Java-implementation of RIPPER.
Classy has no parameters apart from the candidate set, which was generated using FP-growth with and for each dataset (as described at the beginning of Section 6). We tuned CART by selecting the best performing model on the training set from the models generated with the following complexity parameters: . The same was done for C5.0, with confidence factors: . The SVM, with radial kernel, was tuned using -fold cross-validation and a grid search on and within the training set. JRip and FURIA were tuned by setting their hyperparameters to folds, a minimum weight of , and optimization runs.
SBRL was trained using the guidelines provided by the authors [46]: the number of chains was set to ; iterations to ; , representing the average size of patterns in a rule, to ; and , representing the average number of rules, to . The algorithm was first run on the training set and then re-run with changed to the number of rules obtained. In an attempt to follow their guidelines to use around candidate rules, minimum and maximum itemset length were set to and (or if possible) respectively, while the minimum threshold for the negative and positive classes was set to one of . Note that we initially attempted a fair comparison by using the same candidates for SBRL as for Classy, but due to the limitations on the number of rules that SBRL could practically handle this unfortunately turned out to be infeasible.
The results are presented in Table 4. The SVM models achieves the best ranking overall, but they do not belong to the class of interpretable models.
Classy performs on par with most tree- and rule-based models in terms of accuracy and balanced accuracy, worst than FURIA for these two measures, and better than these in terms of AUCs for multiclass datasets. The better performance of FURIA can be explained by the fact that it uses fuzzy rule sets rather than probabilistic rule lists; this allows for multiple rules to be activated and aggregated for a single classification, which improves predictive performance but makes interpretability less straightforward. This also means that the number of rules and conditions cannot be directly compared: a FURIA rule set consisting of rules actually translates to up to unique rules in the rule list setting. Further, FURIA does not provide probabilistic predictions, unlike our approach.
Comparing to other rule list models, such as SBRL and JRip, Classy performs better for most of the measures used. When viewed against the tree-based models, we can see that our method performs on par with CART for most measures and slightly worse than C5.0, except for AUC in the multiclass scenario. Also, as we will show later, C5.0 tends to obtain equivalent rule lists that are much bigger than the ones produced by Classy, which makes them perform better in general (but not always).
[FIGURE:]
6.4 Interpretability
The results are shown in Table 5, where we use AUC, the number of rules, and the number of conditions to compare the trade-off between AUC and model complexity of the tree- and rule-based models. Note that we choose AUC for predictive performance as it agrees with our goal of using the probabilities output of Classy to explain the decisions made. Also note that we intentionally removed FURIA from the rankings of the number of rules and conditions as its models are rule sets—not rule lists.
For binary datasets Classy is in a middle ranking, better than SBRL and JRip, and worst than CART, C5.0 nd FURIA. On the other hand, in multiclass datasets it achieves a much lower (=better) ranking than all the other algorithms.
Classy tends to find more compact models, with similar number of rules and fewer logical conditions in total, than C5.0, CART, and JRip, that are as accurate or better than these. This can be clearly seen by its average rank of and for rules and and for the total number of conditions, for binary and multiclass datasets respectively. It also can be seen that for most datasets it obtained the lowest number of conditions of all tree- and rule-based classifiers. Although SBRL also finds very compact rule lists, with small number of rules and conditions, the low variance between the reported values for the different datasets suggests that this strongly depends on the hyperparameter settings, which penalize too strongly the number of rules not around the user defined expected average number of rules. Indeed, the compact rule lists exhibit subpar classification performance for some datasets (i.e., hepatitis and tictactoe). This suggests that without additional (computation-intensive) tuning of these hyperparameters, the recommended procedure for SBRL may lead to underfitting. As expected, C5.0, with its tendency to maximize the classification performance as much as possible, tends to create overgrown models, such as the almost rules for chessbig, that do not necessarily generalize well, such is the case in adult, where it obtained the same number of rules as Classy but with a lower AUC, and for pendigits were it obtained a number of rules around times higher than Classy and CART for the same performance.
[FIGURE:]
6.5 Statistical significance testing
To analyze whether the results Tables 4 and 5 are statistically different [11], we use two non-parametric multiple hypothesis tests, namely Friedman’s test [14] and Iman and Davenport’s test[22], on the rankings of the algorithms.
The results can be seen in the left side of Table 6, which divides the datasets into two groups, for binary and multiclass datasets respectively. The results show that there are significant differences for most measures (significance level ). The only exceptions are balanced accuracy in the binary case, AUC of rule-based models in the binary case, and the number of rules for the multi-class case.
For those cases where the null hypothesis—stating that the algorithms perform on par—is rejected we proceed with a post-hoc Holm’s test [19] for pairwise comparisons with Classy as control algorithm.
The results of these pairwise comparisons can be seen in the right side of Table 6. For most of these tests the null hypothesis—stating that Classy and its competitor perform on par—cannot be rejected. This can be mostly explained by the relatively small number of datasets; the power of the tests is not very high. We therefore cannot draw strong conclusions from these results, but this is not necessarily a negative outcome: we aimed at showing that Classy performs as well as other rule- and tree-based algorithms while obtaining simpler models. The results show that Classy does use significantly fewer conditions than C5.0 for both multiclass and binary datasets, and than CART for the binary case. Also, as expected the SVM obtained always better results than Classy except for multiclass AUC. FURIA was better in terms of accuracy but worse in terms of AUC.
[FIGURE:]
6.6 Overfitting
To study overfitting, we compared the averages of the absolute difference between the AUC values in the training and test set over times repeated -folds for each algorithm. The results can be seen in Table 7. In general Classy, together with SVM, seem to be the most consistent algorithms in obtaining the lowest values. The usual performance of Classy is or lower, out of times, except in the case of hepatitis were it got , which was the best value after SVM. SBRL is very consistent, clearly achieving the lowest values for binary datasets, however this can be explained by its more conservative choice of rules and thus lower AUC on the test set as shown in Table 4. Comparing with all rule- and tree-based models, Classy obtained the lowest ranking for multiclass datasets, being, from these ones, the algorithm that less overfits overall.
6.7 Runtime
All runtimes are averages over ten times repetitions of ten folds, run on a -bit Windows Server , with Intel Xeon E5-2630v3 CPU at 2.4GHz and 512GB RAM. Runtimes include parameter tuning where applicable, and candidate mining for Classy and SBRL.
The results are depicted in Figure 8. CART, C5.0, JRip and FURIA are the fastest, with most runtimes under minute with Classy being at maximum one order of magnitude slower. Comparing to SBRL, Classy is times faster, even though it considers around times more candidates than this and performs better in terms of AUC. The worst runtimes were obtained for SVM, due to its costly grid search.
It should be noticed that reducing the candidate set size of Classy would have an exponential reduction in its runtimes without much deterioration of its classification performance, as can be seen in Figures 4(a) and 6(a).
6.8 Discussion
From the classification and interpretability results of Table 4 and 5 it can be seen that Classy is able to provide a good trade-off between classification performance and rule list size. This is particularly the case for multiclass datasets such as chessbig, where classical algorithms like JRip find a model with double the number of rules, or in the case of mushroom, where CART and C5.0 find more complex models with the same performance. It is interesting to notice that Classy performs better in terms of AUC than accuracy. This shows that when it makes a wrong prediction it does so with a small probability, which is reassuring. Moreover, Classy has only one hyperparameter — its candidate set — which its tuning is hardly needed as the algorithm has no problem in dealing with large numbers of candidates. This is quite different from the extensive tuning done for the other methods. It is important to observe that all methods except for Classy were tuned.
More importantly, in the set of Figures 7, it is shown that larger candidate sets do not result in worse models, as our formalization in terms of the MDL principle is well-suited to avoid overfitting without the need for cross-validation and/or parameter tuning. In other words, Classy is insensitive to its only parameter — its candidate set — making it virtually parameter-free. This is a big advantage, as one can simply run Classy on all training data with as many candidates as possible, without worrying about any parameters. It also means that all training data can be used for training, which is important in case of small data: no data needs to be reserved for validation.
From Figure 2 we can observe that better compression corresponds to better classification, which is a strong empirical validation of our formalization. As expected, normalized gain is clearly the best heuristic to use in combination with our greedy rule selection strategy, as it results in better classifiers for of the datasets.
From the runtimes of Figure 8, it can be seen that Classy runtimes are slower by an order of magnitude than other (fast) algorithms, such as C5.0, CART, and JRip, and similar to SBRL. This is expected for the size of candidate sets used in our experiments, as can be seen in Table 3.
In terms of classification and interpretability, comparing the average ranking with other rule- and tree-based methods in Table 5, it is shown that Classy performs equally well while also able to find rule lists with less conditions, without any parameter tunning. CART creates models with fewer rules that have more conditions per rule, while C5.0 has a high AUC at the expense of over-complex rules. FURIA has a better performance in terms of both standard and balanced accuracy, and worst in terms of AUC, which is expected as it is not a probabilistic classifier. Also, it is hard to compare its interpretability as all its rules can interact with each other, generating a much larger equivalent rule list than Classy. SBRL on the other hand seems to be able to find simple models that underperform in terms of AUC compared with Classy, which can be either a result of its formalization or because it cannot use larger candidate sets. The experiments also revealed that the Poisson distribution used as prior in SBRL, for the number of conditions per rule and the number of rules, creates tight constraints from which the results hardly deviate. Our results suggest that if the ‘optimal’ values for these hyperparameters are not known in advance, the best model may not be found. An indicative example of this is the tictactoe dataset in Table 4, a deterministic dataset for which SBRL can only find the right amount of rules and logical conditions per rule when given these exact values in advance. The results obtained with Classy demonstrate that using the universal prior for integers alleviates this strong dependence on hyperparameter tuning.
In terms of overfitting, Table 7 shows that Classy has a tendency to select models that generalize well and that are not overconfident in the training set. It obtains low differences between training and test compared with the other rule- and tree-based models.
7 Conclusions and future work
We proposed a novel formalization of the multiclass classification problem using probabilistic rule lists and the minimum description length (MDL) principle. Our problem formulation allows for parameter-free model selection and naturally trades off model complexity with predictive accuracy, effectively avoiding overfitting. To find solutions to this problem, we introduced the heuristic Classy algorithm, which greedily constructs rule lists using the MDL-based criterion.
We empirically demonstrated, on a variety of datasets, that Classy finds probabilistic rule lists that perform on par with state-of-the-art interpretable classifiers with respect to predictive accuracy, despite the fact that some form of hyperparameter tuning is done for all methods except for Classy. Moreover, the models found by our approach were shown to be more compact than those obtained by the other methods, which is expected to make them more understandable in practice. Finally, compression was shown to strongly correlate with predictive accuracy, which can be regarded as an empirical validation of the MDL-based selection criterion.
Directions for future work include, for instance, the following:
Bridge the gap between both kinds of search methods used to learn rule lists from data in a principled way, namely optimal strategies — accurate but slow — and greedy methods — fast but imperfect.
- 2.
Extend our MDL formulation to other types of data and/or tasks, such as continuous data and regression problems.
Acknowledgment
This work is part of the research programme Indo-Dutch Joint Research Programme for ICT 2014 with project number 629.002.201, SAPPAO, which is (partly) financed by the Netherlands Organisation for Scientific Research (NWO).
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1Agrawal et al. [1993] Agrawal, R., Imieliński, T., and Swami, A. (1993). Mining association rules between sets of items in large databases. In Acm sigmod record , volume 22, pages 207–216. ACM.
- 2Alcala-Fdez et al. [2011] Alcala-Fdez, J., Alcala, R., and Herrera, F. (2011). A fuzzy association rule-based classification model for high-dimensional problems with genetic rule selection and lateral tuning. IEEE Transactions on Fuzzy systems , 19(5):857–872.
- 3Angelino et al. [2017] Angelino, E., Larus-Stone, N., Alabi, D., Seltzer, M., and Rudin, C. (2017). Learning certifiably optimal rule lists. In KDD’17 . ACM.
- 4Aoga et al. [2018] Aoga, J. O. R., Guns, T., Nijssen, S., and Schaus, P. (2018). Finding probabilistic rule lists using the minimum description length principle. In DS’18 .
- 5Bellodi and Riguzzi [2015] Bellodi, E. and Riguzzi, F. (2015). Structure learning of probabilistic logic programs by searching the clause space. Theory and Practice of Logic Programming , 15(2):169–212.
- 6Borgelt [2003] Borgelt, C. (2003). Efficient implementations of apriori and eclat. In FIMI’03: Proceedings of the IEEE ICDM workshop on frequent itemset mining implementations .
- 7Breiman et al. [1984] Breiman, L., Friedman, J., Stone, C. J., and Olshen, R. A. (1984). Classification and regression trees . CRC press.
- 8Brodersen et al. [2010] Brodersen, K. H., Ong, C. S., Stephan, K. E., and Buhmann, J. M. (2010). The balanced accuracy and its posterior distribution. In 2010 20th International Conference on Pattern Recognition , pages 3121–3124. IEEE.
