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

rulelearn_ri/trxf/core/conjunction.py

@@ -0,0 +1,50 @@
+from typing import Dict, Any, List
+
+from rulelearn_ri.trxf.core.boolean_evaluator import BooleanEvaluator
+from rulelearn_ri.trxf.core.predicate import Predicate
+from rulelearn_ri.trxf.core.utils import set_equality
+
+
+class Conjunction(BooleanEvaluator):
+    def __init__(self, predicate_list: List[Predicate]):
+        """
+        @param predicate_list: a list of predicates intrpreted as a conjunction
+        """
+        self._predicates = predicate_list
+
+    @property
+    def predicates(self):
+        return self._predicates
+
+    def add_predicate(self, pred: Predicate):
+        self._predicates.append(pred)
+
+    def delete_predicate(self, pred: Predicate):
+        self._predicates.remove(pred)
+
+    def evaluate(self, assignment: Dict[str, Any]) -> bool:
+        """
+        Evaluate the truth value of the conjunction w.r.t. the variable assignment
+
+        @param assignment: dict mapping variable name to value
+        @return: bool truth value of the predicate
+        """       
+        for pred in self.predicates:
+            if not pred.evaluate(assignment):
+                return False
+        return True
+
+    def __repr__(self):
+        return '%s(%r)' %(self.__class__, self._predicates)
+
+    def __str__(self):
+        if len(self.predicates) == 0:
+            return 'true'
+        else:
+            return ' ^ '.join(['['+str(x)+']' for x in self._predicates])
+
+    def __eq__(self, other):
+        return set_equality(self.predicates, other.predicates)
+
+    def __len__(self):
+        return len(self.predicates)

rulelearn_ri/trxf/core/dnf_ruleset.py

@@ -0,0 +1,64 @@
+from typing import Dict, List, Any
+
+from rulelearn_ri.trxf.core.boolean_evaluator import BooleanEvaluator
+from rulelearn_ri.trxf.core.conjunction import Conjunction
+from rulelearn_ri.trxf.core.utils import set_equality
+
+
+class DnfRuleSet(BooleanEvaluator):
+    """
+    This class implements a ruleset in the disjunctive normal form: c_1 v c_2 v .... v c_k. Here, each c_i is a
+    conjunction of predicates, i.e., c_i = p_{i1} & p_{i2} & ... & p_{i n_i}. All the conjunctions share the same
+    conclusion, specified by the then_part of the ruleset.
+    """
+
+    def __init__(self, conjunctions: List[Conjunction], then_part: Any) -> None:
+        """
+        @param conjunctions: A list containing conjunctions in this ruleset
+        @param then_part: The then part of this RuleSet.
+        """
+        self._then_part = then_part
+        self._conjunctions = []
+        for conjunction in conjunctions:
+            if conjunction not in self._conjunctions:
+                self._conjunctions.append(conjunction)
+
+    @property
+    def conjunctions(self):
+        return self._conjunctions
+
+    @property
+    def then_part(self):
+        return self._then_part
+
+    def add_conjunction(self, conjunction: Conjunction) -> None:
+        if conjunction not in self._conjunctions:
+            self._conjunctions.append(conjunction)
+
+    def remove_conjunction(self, conjunction: Conjunction) -> None:
+        self._conjunctions.remove(conjunction)
+
+    def list_conjunctions(self) -> List[Conjunction]:
+        return self.conjunctions
+
+    def evaluate(self, assignment: Dict[str, Any]) -> bool:
+        for conjunction in self.conjunctions:
+            if conjunction.evaluate(assignment):
+                return True
+        return False
+
+    def __repr__(self):
+        return '%s(%r, %r)' % (self.__class__, self._conjunctions, self._then_part)
+
+    def __str__(self):
+        if len(self.conjunctions) == 0:
+            disjunction = 'false'
+        else:
+            disjunction = ' v\n'.join(['(' + str(x) + ')' for x in self._conjunctions])
+        return 'if\n' + disjunction + '\nthen\n' + str(self._then_part)
+
+    def __eq__(self, other):
+        return set_equality(self.conjunctions, other.conjunctions) and self.then_part == other.then_part
+
+    def __len__(self):
+        return len(self.conjunctions)

rulelearn_ri/trxf/core/feature.py

@@ -0,0 +1,155 @@
+import numbers
+import tokenize
+from io import BytesIO
+from typing import Dict, Any
+
+OPERATORS = ['+', '-', '*', '/']
+PARENTHESES = ['(', ')']
+
+
+def is_number(s):
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+
+class Feature:
+    def __init__(self, expression: str):
+        """
+        @param expression: Infix arithmetic expression encoded as utf-8 string involving constants, operators (+, -,
+        *, /), parentheses, and variable names. Variable names shall not have any of the above operators or
+        whitespace as part of the name. Care must be taken not to use the utf-8 long dash '\xe2' for the minus sign,
+        when copy-pasting.
+        """
+        self._expression = expression
+        self._rpn = _shunting_yard(self._expression)
+
+    @property
+    def variable_names(self):
+        """
+        A list of variable names in the feature representation
+        """
+        tokens = _get_tokens(self._expression)
+        return [x for x in tokens if x not in OPERATORS + ['(', ')'] and not is_number(x)]
+
+    @property
+    def reverse_polish_notation(self):
+        """
+        The Reverse Polish Notation (https://en.wikipedia.org/wiki/Reverse_Polish_notation) representation of the
+        feature as a list of token strings. This serves as the symbolic representation of the feature.
+        """
+        return self._rpn
+
+    def evaluate(self, assignment: Dict[str, Any]) -> Any:
+        """
+        Evaluate the value of the feature for the provided variable assignment
+
+        @param assignment: dict mapping variable name to value
+        @return: the feature value w.r.t. the assignment
+        """
+        operand_stack = []
+        for token in self.reverse_polish_notation:
+            if token in OPERATORS:
+                rhs = operand_stack.pop()
+                _validate_number(rhs)
+                lhs = operand_stack.pop()
+                _validate_number(lhs)
+                expression = str(lhs) + token + str(rhs)
+                try:
+                    operand_stack.append(eval(expression))
+                except NameError as e:
+                    raise ValueError(
+                        'eval() failed for expression "{}"'.format(expression)) from e
+            else:
+                operand = assignment[token] if token in assignment else float(token)
+                operand_stack.append(operand)
+        assert len(operand_stack) == 1
+
+        result = operand_stack.pop()
+        try:
+            result = float(result)
+        except ValueError:
+            pass
+        return result
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__, self.reverse_polish_notation)
+
+    def __str__(self):
+        return ' '.join(self._expression.split())
+
+    def __eq__(self, other):
+        return self.__repr__() == other.__repr__()
+
+
+def _shunting_yard(expression):
+    """
+    Converts infix expression string into Reverse Polish Notation.
+    https://en.wikipedia.org/wiki/Shunting-yard_algorithm
+    """
+    tokens = _get_tokens(expression)
+    if len(tokens) > 0 and (tokens[0] == '-' or tokens[0] == '+'):
+        tokens.insert(0, 0)
+    op_precedence = {'+': 1, '-': 1, '*': 2, '/': 2}
+    output = []
+    op_stack = []
+    for token in tokens:
+        if token in OPERATORS:
+            while len(op_stack) > 0 and op_stack[-1] != '(' and op_precedence[op_stack[-1]] >= op_precedence[token]:
+                output.append(op_stack.pop())
+            op_stack.append(token)
+        elif token == '(':
+            op_stack.append(token)
+        elif token == ')':
+            while len(op_stack) > 0 and op_stack[-1] != '(':
+                output.append(op_stack.pop())
+            if len(op_stack) == 0:
+                raise ValueError('Unmatched closing parenthesis in expression: ' + expression)
+            op_stack.pop()
+        else:
+            output.append(token)
+    while len(op_stack) > 0:
+        if op_stack[-1] == '(':
+            raise ValueError('Unmatched opening parenthesis in expression: ' + expression)
+        output.append(op_stack.pop())
+
+    _validate_rpn(output, expression)
+    return output
+
+
+def _get_tokens(expression):
+    no_whitespace = ''.join(expression.split())
+    g = tokenize.tokenize(BytesIO(no_whitespace.encode('UTF-8')).readline)
+    assert next(g).string == 'utf-8'
+    tokens = []
+    buffer = ''
+    result = []
+    for _, v, _, _, _ in g:
+        tokens.append(v)
+    for token in tokens:
+        if token not in OPERATORS + PARENTHESES:
+            buffer += token
+        else:
+            result.append(buffer)
+            result.append(token)
+            buffer = ''
+    result.append(buffer)
+    return [x for x in result if x != '']
+
+
+def _validate_rpn(rpn, expression):
+    stack_size = 0
+    for token in rpn:
+        valence = 2 if token in OPERATORS else 0
+        stack_size += 1 - valence
+        if stack_size <= 0:
+            raise ValueError('Invalid RPN {} for expression "{}"'.format(rpn, expression))
+    if stack_size != 1:
+        raise ValueError('Invalid RPN {} for expression "{}"'.format(rpn, expression))
+
+
+def _validate_number(value):
+    if not isinstance(value, numbers.Number) or isinstance(value, bool):
+        raise ValueError('{} is not a number.'.format(value))

rulelearn_ri/trxf/core/predicate.py

@@ -0,0 +1,98 @@
+import math
+from enum import Enum
+from typing import Dict, Any
+
+from rulelearn_ri.trxf.core.boolean_evaluator import BooleanEvaluator
+from rulelearn_ri.trxf.core.feature import Feature, is_number
+
+ABS_TOL = 1e-5
+
+
+class Relation(Enum):
+    NEQ = '!='
+    EQ = '=='
+    LT = '<'
+    LE = '<='
+    GT = '>'
+    GE = '>='
+
+    def __neg__(self):
+        neg_table = {
+            self.NEQ: self.EQ,
+            self.EQ: self.NEQ,
+            self.LT: self.GE,
+            self.GE: self.LT,
+            self.LE: self.GT,
+            self.GT: self.LE
+        }
+        return neg_table[self]
+
+
+class Predicate(BooleanEvaluator):
+    def __init__(self, feature: Feature, relation: Relation, value: Any):
+        """
+        @param feature: the LHS of the relation
+        @param value: the RHS of the relation
+        """
+        self._feature = feature
+        self._relation = relation
+        self._value = value
+        _validate_predicate(self._relation, self._value)
+
+    @property
+    def feature(self):
+        return self._feature
+
+    @property
+    def relation(self):
+        return self._relation
+
+    @property
+    def value(self):
+        return self._value
+
+    def evaluate(self, assignment: Dict[str, Any]) -> bool:
+        """
+        Evaluate the truth value of the predicate w.r.t. the variable assignment
+
+        @param assignment: dict mapping variable name to value
+        @return: bool truth value of the predicate
+        """
+        feature_val = self.feature.evaluate(assignment)
+        if self.relation == Relation.EQ:
+            return math.isclose(float(feature_val), float(self.value), abs_tol=ABS_TOL) if is_number(self.value) \
+                else feature_val == self.value
+        elif self.relation == Relation.NEQ:
+            return feature_val != self.value
+        elif self.relation == Relation.GE:
+            return feature_val >= self.value
+        elif self.relation == Relation.GT:
+            return feature_val > self.value
+        elif self.relation == Relation.LE:
+            return feature_val <= self.value
+        elif self.relation == Relation.LT:
+            return feature_val < self.value
+        else:
+            raise ValueError('Unknown relation operator {}'.format(self.relation))
+
+    def __neg__(self):
+        if self.value is True or self.value is False:
+            return Predicate(self.feature, self.relation, not self.value)
+        return Predicate(self.feature, -self.relation, self.value)
+
+    def __repr__(self):
+        return '%s(%r, %r, %r)' % (self.__class__, self.feature, self.relation, self.value)
+
+    def __str__(self):
+        return ' '.join([str(self.feature), str(self.relation.value), str(self.value)])
+
+    def __eq__(self, other):
+        return self.feature == other.feature and self.relation == other.relation and self.value == other.value
+
+
+def _validate_predicate(relation, value):
+    if (isinstance(value, str) or isinstance(value, bool)) and relation != Relation.EQ and relation != Relation.NEQ:
+        raise ValueError('String or boolean value "{}" can only be compared through "==" or "!=" but was "{}"'
+                         .format(value, relation.value))
+
+

rulelearn_ri/trxf/core/ruleset_generator.py

@@ -0,0 +1,25 @@
+import abc
+from typing import Any
+
+import pandas as pd
+
+from rulelearn_ri.trxf.core.dnf_ruleset import DnfRuleSet
+
+
+class RuleSetGenerator(metaclass=abc.ABCMeta):
+    @classmethod
+    def __subclasshook__(cls, subclass):
+        return callable(subclass.generate)
+
+    @abc.abstractmethod
+    def generate(self, X: pd.DataFrame, y: pd.Series, to_learn: Any, **kwargs) -> DnfRuleSet:
+        """
+        Train a rule induction algorithm and generate a trxf DnfRuleSet
+
+        @param X: pandas dataframe representing features
+        @param y: pandas series representing labels
+        @param to_learn: one of the unique values of y we want to learn, representing the positive class
+        @param kwargs: algorithm-specific parameters
+        @return: a trxf DnfRuleSet
+        """
+        raise NotImplementedError

rulelearn_ri/trxf/core/utils.py

@@ -0,0 +1,40 @@
+import pandas as pd
+
+from rulelearn_ri.trxf.core.boolean_evaluator import BooleanEvaluator
+
+
+def set_equality(list1: list, list2: list) -> bool:
+    """
+    Equivalent to set(list1) == set(list2) but checks the set inequality manually for lists containing elements that are
+    not hashable.
+
+    @param list1: The first list
+    @param list2: The second list
+
+    @return bool: Whether the two lists are equal when converted to sets
+    """
+
+    equality = True
+    for item in list1:
+        if item not in list2:
+            equality = False
+            break
+
+    for item in list2:
+        if item not in list1:
+            equality = False
+            break
+
+    return equality
+
+
+def batch_evaluate(evaluator: BooleanEvaluator, X: pd.DataFrame) -> pd.Series:
+    """
+    Evaluate the truth value of the evaluator for each row of X, representing the assignments
+
+    @param evaluator: a BooleanEvaluator, e.g., DnfRuleSet, Conjunction, etc.
+    @param X: pandas dataframe where column names represent variable names used by the evaluator
+    @return: pandas series of boolean values representing
+    """
+    assignments = X.to_dict('records')
+    return pd.Series(list(map(lambda assignment: evaluator.evaluate(assignment), assignments)))

rulelearn_ri/trxf/metrics.py

@@ -0,0 +1,98 @@
+from collections import namedtuple
+from copy import deepcopy
+from typing import List
+
+import numpy as np
+import pandas as pd
+from sklearn.metrics import confusion_matrix
+
+from rulelearn_ri.trxf.core.dnf_ruleset import DnfRuleSet
+from rulelearn_ri.trxf.core.utils import batch_evaluate
+
+RuleContributionMetrics = namedtuple(
+    'RuleContributionMetrics',
+    'conjunction, tp_common, tp_unique, fp_common, fp_unique, n_correct, n_records, laplace_estimate')
+"""
+conjunction: a trxf Conjunction object
+tp_common: count of true positives identified based on this and at least one other rule (large values indicate redundancy)
+tp_unique: count of true positives correctly identifying a label based only on this rule (indicates strength of the rule)
+fp_common: count of false positives based on this and at least one other rule
+fp_unique: count of false positives, i.e. mis-classified instances, based on this rule alone 
+n_correct: count of true positives + true_negatives
+n_records: total number of instances
+laplace_estimate: metric of confidence (https://en.wikipedia.org/wiki/Additive_smoothing)
+"""
+
+RuleComplexityMetrics = namedtuple('RuleComplexityMetrics',
+                                   'num_rules, max_rule_length, sum_rule_length, num_distinct_predicates')
+
+
+def compute_ruleset_metrics(ruleset: DnfRuleSet, X: pd.DataFrame, y: pd.Series):
+    """
+    Compute ruleset-level confusion matrix and accuracy when used as a binary classifier
+
+    @param X: features
+    @param y: labels
+    @return: a dict describing the confusion matrix and accuracy
+    """
+    then_part = ruleset.then_part
+    y_true = (y == then_part)
+    y_pred = batch_evaluate(ruleset, X)
+    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+    accuracy = (tn + tp) / len(y)
+    return {'tn': tn, 'fp': fp, 'fn': fn, 'tp': tp, 'accuracy': accuracy}
+
+
+def compute_rule_metrics(ruleset: DnfRuleSet, X: pd.DataFrame, y: pd.Series) -> List[RuleContributionMetrics]:
+    """
+    Compute individual rule-level contribution to coverage and redundancy.
+    See https://ibm.ent.box.com/file/888961054325?sb=/activity/annotations/956283151925 for more context.
+
+    @param X: features
+    @param y: labels
+    @return: a dict mapping the string representation of conjunctions to a dict containing the contribution metrics
+    """
+    then_part = ruleset.then_part
+    res = []
+    for conjunction in ruleset.conjunctions:
+        complement = deepcopy(ruleset)
+        complement.remove_conjunction(conjunction)
+        y_pred_compl = batch_evaluate(complement, X)
+        tp_compl, tn_compl, fp_compl, fn_compl = get_preaggregated_confusion_matrix(y_pred_compl, y, then_part)
+        y_pred_conj = batch_evaluate(conjunction, X)
+        tp_conj, tn_conj, fp_conj, fn_conj = get_preaggregated_confusion_matrix(y_pred_conj, y, then_part)
+        laplace_estimate = (len(tp_conj) + 1) / (len(tp_conj) + len(fp_conj) + 2)
+
+        tp_common = len(set(tp_conj).intersection(set(tp_compl)))
+        tp_unique = len(set(tp_conj).difference(set(tp_compl)))
+        fp_common = len(set(fp_conj).intersection(set(fp_compl)))
+        fp_unique = len(set(fp_conj).difference(set(fp_compl)))
+        n_correct = len(tn_conj) + len(tp_conj)
+        n_records = X.shape[0]
+        res.append(RuleContributionMetrics(
+            conjunction, tp_common, tp_unique, fp_common, fp_unique, n_correct, n_records, laplace_estimate))
+    return res
+
+
+def compute_ruleset_complexity(ruleset: DnfRuleSet):
+    num_rules = len(ruleset)
+    rule_lengths = list(map(len, ruleset.conjunctions))
+    max_rule_length = max(rule_lengths)
+    sum_rule_length = sum(rule_lengths)
+    predicates = []
+    for c in ruleset.conjunctions:
+        predicates += [p for p in c.predicates if p not in predicates]
+    num_distinct_predicates = len(predicates)
+    return RuleComplexityMetrics(num_rules, max_rule_length, sum_rule_length, num_distinct_predicates)
+
+
+def get_preaggregated_confusion_matrix(y_pred, y_true, pos_value):
+    y_p = y_pred.to_numpy()
+    y_t = (y_true.to_numpy() == pos_value)
+
+    tp = np.where(y_p & y_t)[0]
+    tn = np.where(np.logical_not(y_p) & np.logical_not(y_t))[0]
+    fp = np.where(y_p & np.logical_not(y_t))[0]
+    fn = np.where(y_t & np.logical_not(y_p))[0]
+
+    return tp, tn, fp, fn

rulelearn_ri/trxf/pmml_export/__init__.py

@@ -0,0 +1,4 @@
+from .__version__ import version
+from .reader import AbstractReader, TrxfReader
+from .serializer import AbstractSerializer, NyokaSerializer
+from .pmml_exporter import PmmlExporter

rulelearn_ri/trxf/pmml_export/__version__.py

@@ -0,0 +1 @@
+version = '0.0.1'

rulelearn_ri/trxf/pmml_export/models/__init__.py

@@ -0,0 +1,24 @@
+from .data_dictionary import DataDictionary
+from .data_dictionary import DataField
+from .data_dictionary import DataType
+from .data_dictionary import OpType
+from .data_dictionary import Value
+from .data_dictionary import Restriction
+from .mining_schema import MiningField
+from .mining_schema import MiningFieldUsageType
+from .mining_schema import MiningSchema
+from .predicate import BooleanOperator
+from .predicate import CompoundPredicate
+from .predicate import Operator
+from .predicate import SimplePredicate
+from .predicate import TruePredicate
+from .rule import SimpleRule
+from .rule import DEFAULT_WEIGHT
+from .rule import DEFAULT_CONFIDENCE
+from .ruleset import RuleSelectionMethod
+from .ruleset import RuleSet
+from .ruleset_model import RuleSetModel
+from .pmml_ruleset_model import SimplePMMLRuleSetModel
+from .scorecard import Scorecard, Output, OutputField
+from .characteristics import Characteristics, Characteristic
+from .attribute import Attribute, ComplexPartialScore

rulelearn_ri/trxf/pmml_export/models/attribute.py

@@ -0,0 +1,24 @@
+import typing
+
+from . import predicate
+
+try:
+    # python >= 3.7
+    from dataclasses import dataclass as dataclass
+    from dataclasses import field as field
+except ImportError:
+    from attr import s as dataclass
+    from attr import ib as field
+
+
+@dataclass(frozen=True)
+class ComplexPartialScore:
+    feature_name: str = field()
+    multiplier: str = field(default=None)
+    constant: str = field(default=None)
+
+
+@dataclass(frozen=True)
+class Attribute:
+    score: typing.Union[str, ComplexPartialScore]
+    predicate: typing.Union[predicate.SimplePredicate, predicate.CompoundPredicate, predicate.TruePredicate]

rulelearn_ri/trxf/pmml_export/models/characteristics.py

@@ -0,0 +1,20 @@
+import typing
+
+from . import attribute
+
+try:
+    # python >= 3.7
+    from dataclasses import dataclass as dataclass
+except ImportError:
+    from attr import s as dataclass
+
+
+@dataclass(frozen=True)
+class Characteristic:
+    name: str
+    attributes: typing.List[attribute.Attribute]
+
+
+@dataclass(frozen=True)
+class Characteristics:
+    characteristics: typing.List[Characteristic]

rulelearn_ri/trxf/pmml_export/models/data_dictionary.py

@@ -0,0 +1,53 @@
+try:
+    # python >= 3.7
+    from dataclasses import dataclass as dataclass
+    from dataclasses import field as field
+except ImportError:
+    from attr import s as dataclass
+    from attr import ib as field
+import enum
+import typing
+
+
+class DataType(enum.Enum):
+    string = 0
+    integer = 1
+    float = 2
+    double = 3
+    boolean = 4
+
+
+class OpType(enum.Enum):
+    categorical = 0
+    ordinal = 1
+    continuous = 2
+
+
+class Restriction(enum.Enum):
+    valid = 0
+    invalid = 1
+    missing = 2
+
+
+@dataclass(frozen=True)
+class Value:
+    value: str = field()
+    property: Restriction = field(default=Restriction.valid)
+
+
+@dataclass(frozen=True)
+class DataField:
+    name: str = field()
+    optype: OpType = field()
+    dataType: DataType = field()
+    values: typing.Optional[typing.List[Value]] = field(default=None)
+
+    def __post_init__(self):
+        if self.values and \
+                (self.dataType is not DataType.string or self.optype not in (OpType.ordinal, OpType.categorical)):
+            raise ValueError
+
+
+@dataclass(frozen=True)
+class DataDictionary:
+    dataFields: typing.List[DataField] = field()