rulelearn-ripper-interactive 0.2.3__py3-none-any.whl

rulelearn_ri/algorithms/r2n/training.py

@@ -0,0 +1,34 @@
+import torch
+
+import rulelearn_ri.algorithms.r2n.utilities as util
+
+
+def train(dataloader, model, loss_fn, optimizer, temp, min_temp, decay_rate, coef, mv_reg=1e-4, multivariate=False):
+    thresholdnet = model[0].LearningLayer
+    rulenet = model[1]
+    succes_rate, loop_loss = 0, 0
+
+    for batch, ((X_cat, X_num), y) in enumerate(dataloader):
+        x = [X_cat.float(), X_num.float()]
+        pred = model(x).T
+
+        loss = loss_fn(pred, y.float()) + coef * rulenet.get_penalty()
+        if multivariate:
+            loss += mv_reg * thresholdnet.get_penalty()
+
+        # Backpropagation
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1)
+        optimizer.step()
+
+        # Calculating metric
+        succes_rate += util.binary_acc(pred, y).item()
+        loop_loss += loss.item()
+    # Cooling schedule
+    temp = temp * decay_rate if temp > min_temp else temp
+    if multivariate:
+        thresholdnet.update_temp(temp)
+    rulenet.update_temp(temp)
+
+    return temp, loop_loss, succes_rate / len(dataloader)

rulelearn_ri/algorithms/r2n/utilities.py

@@ -0,0 +1,117 @@
+from functools import partial
+
+import numpy as np
+import sklearn.metrics as metrics
+import torch
+
+basic_metrics_binary = dict(
+    acc=metrics.accuracy_score,
+    bal_acc=metrics.balanced_accuracy_score,
+    f1=lambda y_true, y_pred: metrics.f1_score(y_true, y_pred, average="weighted"),
+    precision=lambda y_true, y_pred: metrics.precision_score(y_true, y_pred, average="weighted"),
+    recall=lambda y_true, y_pred: metrics.recall_score(y_true, y_pred, average="weighted"),
+)
+
+
+def binary_acc(y_pred, y_test):
+    y_pred_tag = torch.round(y_pred)
+
+    correct_results_sum = (y_pred_tag == y_test).sum().float()
+    acc = correct_results_sum / y_test.shape[0]
+    acc = torch.round(acc * 100)
+
+    return acc
+
+
+def compute_metrics(y_true, y_pred):
+    res = dict()
+    for metric in basic_metrics_binary:
+        res[metric] = basic_metrics_binary[metric](y_true, y_pred)
+    return res
+
+
+def apply_ruleset(ruleset, x):
+    """ Apply a ruleset to an input vector
+
+    :param ruleset: A 2D list conforming to the format of the output of `extract_ruleset()`
+    :param x: A list-like object of 0/1 values representing a single input vector
+    :return: The truth value of applying ruleset to x
+    """
+    transform = {1: lambda z: z == 1,
+                 0: lambda z: True,
+                 -1: lambda z: z == 0}
+    or_result = False
+    for rule in ruleset:
+        and_result = True
+        for i, t in enumerate([transform[r] for r in rule]):
+            and_result &= t(x[i])
+        or_result |= and_result
+    return or_result
+
+
+def batch_apply_ruleset(ruleset, xs):
+    """ Batch-apply a ruleset to a list of input vectors
+
+    :param ruleset: A 2D list conforming to the format of the output of `extract_ruleset()`
+    :param xs: A (2D) list-like object of input vectors
+    :return: A list of truth values corresponding to each input vector in xs
+    """
+    return list(map(partial(apply_ruleset, ruleset), xs))
+
+
+def _rchop(s, suffix):
+    if suffix and s.endswith(suffix):
+        return s[:-len(suffix)]
+    return s
+
+
+def filter_trivial_predicates(set_of_rules, pred_evaluation):
+    """
+    This function filters the ruleset by evaluating the rules and predicates on a dataset X.
+    It returns a ruleset that filters all the always true predicates and removes the rules that contain an always false predicate.
+
+    @param set_of_rules: 2D binary list representing a ruleset.
+    @param pred_evaluation: 2D binary `np.array` representing the evaluation of each predicate on the input data. Equal to the transpose of the binarized data.
+    @return: 2D binary list representing a ruleset.
+    """
+    # Evaluate which of the predicates evaluate to Always true or always False
+
+    always_true = np.count_nonzero(pred_evaluation, axis=1) / pred_evaluation.shape[1] == 1
+    always_false = np.count_nonzero(pred_evaluation, axis=1) / pred_evaluation.shape[1] == 0
+    # Remove the predicates that are always True
+    set_of_rules = [np.array(i, dtype=int) for i in set_of_rules]
+    for i in set_of_rules:
+        i[always_true] = 0
+        # Select and remove the rules have at least one always False predicate
+    always_false_rules = [np.count_nonzero(np.logical_and(rule, always_false)) for rule in set_of_rules]
+    set_of_rules = [i for i, j in zip(set_of_rules, always_false_rules) if j == 0]
+
+    return set_of_rules
+
+
+def simplify_ruleset(ruleset):
+    ruleset = [rule for rule in ruleset if
+               np.count_nonzero(rule) != 0]  # Remove the ALWAYS FALSE rules in the disjunction.
+    simplified_rules = []
+    for rule1 in ruleset:
+        is_redundant = False
+        for rule2 in ruleset:
+            if not np.array_equal(rule2, rule1) and _subsumes(rule2, rule1):
+                is_redundant = True
+                break
+        if not is_redundant:
+            simplified_rules.append(rule1)
+    simplified_rules = _deduplicate(simplified_rules)
+
+    return simplified_rules
+
+
+def _deduplicate(simplified_rules):
+    tupled_lst = set(map(tuple, simplified_rules))
+    simplified_rules = list(map(list, tupled_lst))
+    simplified_rules = [np.array(i, dtype=int) for i in simplified_rules]
+    return simplified_rules
+
+
+def _subsumes(rule1, rule2):
+    return np.array_equal(np.logical_and(rule1, rule2), rule1)

rulelearn_ri/algorithms/rbm/boolean_rule_cg.py

@@ -0,0 +1,65 @@
+from rulelearn_ri.algorithms.rbm.rbm import BooleanRuleCG as brcg
+
+from rulelearn_ri.trxf.core.dnf_ruleset import DnfRuleSet, Conjunction
+from rulelearn_ri.trxf.core.predicate import Predicate, Feature
+from .utils import OPERATOR_MAPS
+
+
+class BooleanRuleCG(brcg):
+    """
+    Same class as `aix360.algorithms.rbm.boolean_rule_cg.BooleanRuleCG`, the only 
+    difference being that the explanations are available in the Technical Rule 
+    Exchange Format (TRXF). 
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def explain(self, maxConj=None, prec=2) -> DnfRuleSet:
+        """
+        Overriden method that returns the BRCG learnt rules as a TRXF Ruleset.
+        """
+        # Selected conjunctions
+        z = self.z.loc[:, self.w > 0.5]
+        truncate = (maxConj is not None) and (z.shape[1] > maxConj)
+        nConj = maxConj if truncate else z.shape[1]
+
+        # Sort conjunctions by increasing order
+        idxSort = z.sum().sort_values().index[:nConj]
+        
+        # Iterate over sorted conjunctions
+        conj = [] # List of conjunctions
+        for i in idxSort:
+            pred_list = []
+            
+            # MultiIndex of features participating in rule i
+            idxFeat = z.index[z[i] > 0]
+
+            # String representations of features
+            feats = idxFeat.get_level_values(0)
+            ops = idxFeat.get_level_values(1)
+            values = idxFeat.get_level_values(2).to_series()
+                     
+            for f, o, v in zip(feats, ops, values):
+
+                if o in ['', 'not']: 
+                    if "=" in f:
+                        # Encoded feature
+                        f, v = f.split("=")
+                    else:
+                        # boolean column
+                        v = True # force values for boolean columms
+                
+                pred_list.append(Predicate(Feature(f), OPERATOR_MAPS[o], v))
+            
+            c = Conjunction(predicate_list=pred_list)
+            conj.append(c)
+        
+        if self.CNF:
+            then_part = 0 
+        else:
+            then_part = 1
+        
+        res = DnfRuleSet(conjunctions=conj,then_part=then_part)
+
+        return res

rulelearn_ri/algorithms/rbm/rbm/BRCG.py

@@ -0,0 +1,69 @@
+from rulelearn_ri.dise import DISExplainer
+
+
+class BRCGExplainer(DISExplainer):
+    """
+    Boolean Rule Column Generation explainer. Provides access to 
+    :class:`aix360.algorithms.rbm.boolean_rule_cg.BooleanRuleCG`, which
+    implements a directly interpretable supervised learning method
+    for binary classification that learns a Boolean rule in disjunctive
+    normal form (DNF) or conjunctive normal form (CNF) using column generation (CG).
+    AIX360 implements a heuristic beam search version of BRCG that is less 
+    computationally intensive than the published integer programming version [#NeurIPS2018]_.
+
+    References:
+        .. [#NeurIPS2018] `S. Dash, O. Günlük, D. Wei, "Boolean decision rules via
+           column generation." Neural Information Processing Systems (NeurIPS), 2018.
+           <https://papers.nips.cc/paper/7716-boolean-decision-rules-via-column-generation.pdf>`_
+    """
+
+    def __init__(self, model):
+        """
+        Initialize a BRCGExplainer object.
+
+        Args:
+          model: model to operate on, instance of :class:`aix360.algorithms.rbm.boolean_rule_cg.BooleanRuleCG`
+        """
+        super(BRCGExplainer, self).__init__()
+        self._model = model
+
+    def set_params(self, *argv, **kwargs):
+        """
+        Set parameters for the explainer.
+        """
+        pass
+
+    def fit(self, X_train, Y_train, *argv, **kwargs):
+        """Fit model to training data.
+
+        Args:
+            X_train (DataFrame): Binarized features with MultiIndex column labels
+            Y_train (array): Binary-valued target variable
+        Returns:
+            BRCGExplainer: Self
+        """
+        self._model.fit(X_train, Y_train, **kwargs)
+
+    def predict(self, X, *argv, **kwargs):
+        """Predict class labels.
+
+        Args:
+            X (DataFrame): Binarized features with MultiIndex column labels
+        Returns:
+            array: y -- Predicted labels
+        """
+        return self._model.predict(X, **kwargs)
+
+    def explain(self, *argv, **kwargs):
+        """Return rules comprising the underlying model.
+
+        Args:
+            maxConj (int, optional): Maximum number of conjunctions to show
+            prec (int, optional): Number of decimal places to show for floating-value thresholds
+        Returns:
+            Dictionary containing
+
+            * isCNF (bool): flag signaling whether model is CNF or DNF
+            * rules (list): selected conjunctions formatted as strings
+        """
+        return self._model.explain(**kwargs)

rulelearn_ri/algorithms/rbm/rbm/GLRM.py

@@ -0,0 +1,98 @@
+from rulelearn_ri.dise import DISExplainer
+
+
+class GLRMExplainer(DISExplainer):
+    """
+    Generalized Linear Rule Model explainer. Provides access to the following
+    directly interpretable supervised learning methods:
+
+    * **Linear Rule Regression:** linear regression on rule-based features [#Icml2019]_.
+    * **Logistic Rule Regression:** logistic regression on rule-based features [#Icml2019]_.
+
+    References:
+        .. [#Icml2019] `D. Wei, S. Dash, T. Gao, O. Günlük, "Generalized linear rule
+           models." International Conference on Machine Learning (ICML), 2019.
+           <http://proceedings.mlr.press/v97/wei19a/wei19a.pdf>`_
+    """
+
+    def __init__(self, model):
+        """
+        Initialize a GLRMExplainer object.
+
+        Args:
+          model: model to operate on. Instance of either
+
+            * :class:`aix360.algorithms.rbm.linear_regression.LinearRuleRegression` or
+            * :class:`aix360.algorithms.rbm.logistic_regression.LogisticRuleRegression`
+        """
+        super(GLRMExplainer, self).__init__()
+        self._model = model
+
+    def set_params(self, *argv, **kwargs):
+        """
+        Set parameters for the explainer.
+        """
+        pass
+
+    def fit(self, X_train, Y_train, Xstd=None):
+        """Fit model to training data.
+
+        Args:
+            X_train (DataFrame): Binarized features with MultiIndex column labels
+            Y_train (array): Target variable
+            Xstd (DataFrame, optional): Standardized numerical features
+        Returns:
+            GLRMExplainer: Self
+        """
+        self._model.fit(X_train, Y_train, Xstd)
+
+    def predict(self, X, Xstd=None):
+        """Predict responses.
+
+        Args:
+            X (DataFrame): Binarized features with MultiIndex column labels
+            Xstd (DataFrame, optional): Standardized numerical features
+        Returns:
+            array: y -- Predicted responses
+        """
+        return self._model.predict(X, Xstd)
+
+    def predict_proba(self, X, Xstd=None):
+        """Predict probabilities of Y=1. Only available if underlying model implements
+        `predict_proba` method.
+
+        Args:
+            X (DataFrame): Binarized features with MultiIndex column labels
+            Xstd (DataFrame, optional): Standardized numerical features
+        Returns:
+            array: p -- Predicted probabilities
+
+        Raises:
+            ValueError: if model doesn't implement `predict_proba`
+        """
+        if hasattr(self._model, 'predict_proba'):
+            return self._model.predict_proba(X, Xstd)
+        raise ValueError("Current model doesn't predict probabilities")
+
+    def explain(self, maxCoeffs=None, highDegOnly=False, prec=2):
+        """Return DataFrame holding model features and their coefficients.
+
+        Args:
+            maxCoeffs (int, optional): Maximum number of rules/numerical features to show
+            highDegOnly (bool, optional): Only show higher-degree rules
+            prec (int, optional): Number of decimal places to show for floating-value thresholds
+        Returns:
+            DataFrame: dfExpl -- Rules/numerical features and their coefficients
+        """
+        return self._model.explain(maxCoeffs, highDegOnly, prec)
+
+    def visualize(self, Xorig, fb, features=None):
+        """Plot generalized additive model component, which includes first-degree rules 
+        and linear functions of unbinarized ordinal features but excludes higher-degree rules.
+
+        Args:
+            Xorig (DataFrame): Original unbinarized features
+            fb: FeatureBinarizer object used to binarize features
+            features (list, optional): Subset of features to be plotted
+        """
+        return self._model.visualize(Xorig, fb, features)

rulelearn_ri/algorithms/rbm/rbm/__init__.py

@@ -0,0 +1,6 @@
+from .features import FeatureBinarizer, FeatureBinarizerFromTrees
+from .linear_regression import LinearRuleRegression
+from .logistic_regression import LogisticRuleRegression
+from .boolean_rule_cg import BooleanRuleCG
+from .GLRM import GLRMExplainer
+from .BRCG import BRCGExplainer