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

rulelearn_ri/trxf/pmml_export/models/mining_schema.py

@@ -0,0 +1,25 @@
+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 MiningFieldUsageType(enum.Enum):
+    active = 0
+    target = 1
+
+
+@dataclass(frozen=True)
+class MiningField:
+    name: str = field()
+    usageType: MiningFieldUsageType = field(default=MiningFieldUsageType.active)
+
+
+@dataclass(frozen=True)
+class MiningSchema:
+    miningFields: typing.List[MiningField] = field()

rulelearn_ri/trxf/pmml_export/models/pmml_ruleset_model.py

@@ -0,0 +1,16 @@
+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
+
+from .data_dictionary import DataDictionary
+from .ruleset_model import RuleSetModel
+
+
+@dataclass(frozen=True)
+class SimplePMMLRuleSetModel:
+    dataDictionary: DataDictionary = field()
+    ruleSetModel: RuleSetModel = field()

rulelearn_ri/trxf/pmml_export/models/predicate.py

@@ -0,0 +1,42 @@
+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 Operator(enum.Enum):
+    equal = 0
+    notEqual = 1
+    lessThan = 2
+    lessOrEqual = 3
+    greaterThan = 4
+    greaterOrEqual = 5
+    isMissing = 6
+
+
+@dataclass(frozen=True)
+class SimplePredicate:
+    operator: Operator = field()
+    field: str = field()
+    value: typing.Optional[str] = None
+
+
+@dataclass(frozen=True)
+class TruePredicate:
+    pass
+
+
+# Use functional api to add aliases for `or` and `and`
+BooleanOperator = enum.Enum('BooleanOperator',
+                            [('or', 0), ('or_', 0), ('and', 1), ('and_', 1), ('xor', 2), ('surrogate', 3)])
+
+
+@dataclass(frozen=True)
+class CompoundPredicate:
+    simplePredicates: typing.List[SimplePredicate] = field()
+    booleanOperator: BooleanOperator = field()

rulelearn_ri/trxf/pmml_export/models/rule.py

@@ -0,0 +1,26 @@
+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 typing
+
+from .predicate import CompoundPredicate
+from .predicate import SimplePredicate
+
+DEFAULT_WEIGHT = 1.0
+DEFAULT_CONFIDENCE = 1.0
+
+
+@dataclass(frozen=True)
+class SimpleRule:
+    predicate: typing.Union[SimplePredicate, CompoundPredicate] = field()
+    score: str = field()
+
+    id: typing.Optional[str] = field(default=None)
+    recordCount: typing.Optional[int] = field(default=None)
+    nbCorrect: typing.Optional[int] = field(default=None)
+    confidence: typing.Optional[float] = field(default=DEFAULT_CONFIDENCE)
+    weight: typing.Optional[float] = field(default=DEFAULT_WEIGHT)

rulelearn_ri/trxf/pmml_export/models/ruleset.py

@@ -0,0 +1,28 @@
+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
+
+from .rule import SimpleRule
+
+
+class RuleSelectionMethod(enum.Enum):
+    firstHit = 0
+    weightedMax = 1
+    weightedSum = 2
+
+
+@dataclass(frozen=True)
+class RuleSet:
+    ruleSelectionMethod: typing.List[RuleSelectionMethod] = field()
+    rules: typing.List[SimpleRule] = field()
+
+    recordCount: typing.Optional[int] = field(default=None)
+    nbCorrect: typing.Optional[int] = field(default=None)
+    defaultScore: typing.Optional[str] = field(default=None)
+    defaultConfidence: typing.Optional[float] = field(default=None)

rulelearn_ri/trxf/pmml_export/models/ruleset_model.py

@@ -0,0 +1,16 @@
+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
+
+from .mining_schema import MiningSchema
+from .ruleset import RuleSet
+
+
+@dataclass(frozen=True)
+class RuleSetModel:
+    miningSchema: MiningSchema = field()
+    ruleSet: RuleSet = field()

rulelearn_ri/trxf/pmml_export/models/scorecard.py

@@ -0,0 +1,35 @@
+import typing
+
+from . import characteristics
+from . import data_dictionary
+from . import mining_schema
+
+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 OutputField:
+    name: str
+    feature: str
+    dataType: data_dictionary.DataType
+    optype: data_dictionary.OpType
+
+
+@dataclass(frozen=True)
+class Output:
+    outputFields: typing.List[OutputField]
+
+
+@dataclass(frozen=True)
+class Scorecard:
+    dataDictionary: data_dictionary.DataDictionary
+    miningSchema: mining_schema.MiningSchema
+    output: Output
+    characteristics: characteristics.Characteristics
+    initialScore: str = field(default="0")

rulelearn_ri/trxf/pmml_export/pmml_exporter.py

@@ -0,0 +1,18 @@
+from rulelearn_ri.trxf.classifier.ruleset_classifier import RuleSetClassifier
+from rulelearn_ri.trxf.pmml_export import AbstractSerializer, AbstractReader
+
+
+class PmmlExporter:
+    def __init__(self, reader: AbstractReader, serializer: AbstractSerializer):
+        self._serializer = serializer
+        self._reader = reader
+
+    def export(self, trxf_classifier: RuleSetClassifier):
+        """
+        Translate a given TRXF RuleSetClassifier to a PMML string
+        @param trxf_classifier: A TRXF RuleSetClassifier
+        @return: The corresponding PMML string
+        """
+        if self._reader.data_dictionary is None:
+            raise AssertionError("Missing data dictionary in reader object")
+        return self._serializer.serialize(self._reader.read(trxf_classifier))

rulelearn_ri/trxf/pmml_export/reader/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_reader import AbstractReader
+from .trxf_reader import TrxfReader

rulelearn_ri/trxf/pmml_export/reader/abstract_reader.py

@@ -0,0 +1,16 @@
+import abc
+import typing
+
+from .. import models
+
+
+class AbstractReader(abc.ABC):
+    T = typing.TypeVar('T')
+
+    @property
+    def data_dictionary(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def read(self, model: T) -> models.SimplePMMLRuleSetModel:
+        raise NotImplementedError

rulelearn_ri/trxf/pmml_export/reader/trxf_reader.py

@@ -0,0 +1,113 @@
+from typing import Dict
+
+import pandas as pd
+from pandas.api.types import is_bool_dtype, is_float_dtype, is_integer_dtype
+
+from rulelearn_ri.trxf.classifier import ruleset_classifier
+from rulelearn_ri.trxf.classifier.ruleset_classifier import RuleSetClassifier
+from rulelearn_ri.trxf.core import Conjunction, Relation
+from rulelearn_ri.trxf.pmml_export import models
+from rulelearn_ri.trxf.pmml_export.models.data_dictionary import Value
+from rulelearn_ri.trxf.pmml_export.reader import AbstractReader
+from rulelearn_ri.trxf.pmml_export.models import SimplePredicate, Operator, CompoundPredicate, \
+    BooleanOperator
+
+
+class TrxfReader(AbstractReader):
+    def __init__(self, data_dictionary=None):
+        self._data_dictionary = data_dictionary
+
+    @property
+    def data_dictionary(self):
+        return self._data_dictionary
+
+    def read(self, trxf_classifier: RuleSetClassifier) -> models.SimplePMMLRuleSetModel:
+        """
+        Translate a TRXF RuleSetClassifier to an internal SimplePMMLRuleSetModel
+        """
+        trxf_to_pmml_rule_selection_map = {
+            ruleset_classifier.RuleSelectionMethod.FIRST_HIT: models.RuleSelectionMethod.firstHit,
+            ruleset_classifier.RuleSelectionMethod.WEIGHTED_SUM: models.RuleSelectionMethod.weightedSum,
+            ruleset_classifier.RuleSelectionMethod.WEIGHTED_MAX: models.RuleSelectionMethod.weightedMax
+        }
+        trxf_rules = trxf_classifier.rules
+        mining_schema = _extract_mining_schema(trxf_rules)
+        simple_rules = _convert_to_simple_rules(trxf_rules)
+        ruleset = models.RuleSet(
+            ruleSelectionMethod=[trxf_to_pmml_rule_selection_map[trxf_classifier.rule_selection_method]],
+            rules=simple_rules,
+            defaultScore=str(trxf_classifier.default_label))
+        rule_set_model = models.RuleSetModel(miningSchema=mining_schema, ruleSet=ruleset)
+        assert self._data_dictionary is not None
+        return models.SimplePMMLRuleSetModel(dataDictionary=self._data_dictionary, ruleSetModel=rule_set_model)
+
+    def load_data_dictionary(self, X: pd.DataFrame, values: Dict = None):
+        """
+        Extract the data dictionary from a feature dataframe, and store it
+
+        @param X: Input dataframe
+        @param values: A dict mapping column name to a list of possible categorical values. It will be inferred from X if not provided.
+        """
+        dtypes = X.dtypes
+        data_fields = []
+        for index, value in dtypes.items():
+            vals = None
+            # pandas dtype predicates also handle extension dtypes (e.g. the pandas 3 default StringDtype),
+            # which np.issubdtype cannot interpret
+            if is_bool_dtype(value):
+                data_type = models.DataType.boolean
+                op_type = models.OpType.categorical
+            elif is_integer_dtype(value):
+                data_type = models.DataType.integer
+                op_type = models.OpType.ordinal
+            elif is_float_dtype(value):
+                data_type = models.DataType.double if value.itemsize == 8 else models.DataType.float
+                op_type = models.OpType.continuous
+            else:
+                data_type = models.DataType.string
+                op_type = models.OpType.categorical
+                vals = values[index] if values is not None and index in values else list(X[index].unique())
+            wrapped_vals = list(map(lambda v: Value(v), vals)) if vals is not None else vals
+            data_fields.append(
+                models.DataField(name=str(index), optype=op_type, dataType=data_type, values=wrapped_vals))
+        self._data_dictionary = models.DataDictionary(data_fields)
+
+
+def _convert_to_simple_rules(trxf_rules):
+    simple_rules = []
+    for rule in trxf_rules:
+        predicate = _convert_to_pmml_predicate(rule.conjunction)
+        confidence = rule.confidence if rule.confidence is not None else models.DEFAULT_CONFIDENCE
+        weight = rule.weight if rule.weight is not None else models.DEFAULT_WEIGHT
+        simple_rule = models.SimpleRule(predicate=predicate, score=str(rule.label), id=str(rule.conjunction),
+                                        recordCount=rule.record_count,
+                                        nbCorrect=rule.nb_correct, confidence=confidence, weight=weight)
+        simple_rules.append(simple_rule)
+    return simple_rules
+
+
+def _convert_to_pmml_predicate(trxf_conjunction: Conjunction):
+    trxf_to_pmml_op = {
+        Relation.EQ: Operator.equal,
+        Relation.NEQ: Operator.notEqual,
+        Relation.LT: Operator.lessThan,
+        Relation.LE: Operator.lessOrEqual,
+        Relation.GT: Operator.greaterThan,
+        Relation.GE: Operator.greaterOrEqual
+    }
+    simple_predicates = [SimplePredicate(operator=trxf_to_pmml_op[trxf_predicate.relation],
+                                         value=str(trxf_predicate.value),
+                                         field=str(trxf_predicate.feature.variable_names[0]))
+                         for trxf_predicate in trxf_conjunction.predicates]
+    return CompoundPredicate(simplePredicates=simple_predicates, booleanOperator=BooleanOperator.and_)
+
+
+def _extract_mining_schema(trxf_rules):
+    mining_fields = {}
+    for rule in trxf_rules:
+        for predicate in rule.conjunction.predicates:
+            name = predicate.feature.variable_names[0]
+            if name not in mining_fields:
+                mining_field = models.MiningField(name=name)
+                mining_fields[name] = mining_field
+    return models.MiningSchema(miningFields=list(mining_fields.values()))

rulelearn_ri/trxf/pmml_export/serializer/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_serializer import AbstractSerializer
+from .nyoka_serializer import NyokaSerializer

rulelearn_ri/trxf/pmml_export/serializer/abstract_serializer.py

@@ -0,0 +1,11 @@
+import abc
+import typing
+
+from .. import models
+
+
+class AbstractSerializer(abc.ABC):
+
+    @abc.abstractmethod
+    def serialize(self, model: typing.Union[models.SimplePMMLRuleSetModel, models.Scorecard]) -> str:
+        raise NotImplementedError

rulelearn_ri/trxf/pmml_export/serializer/nyoka_serializer.py

@@ -0,0 +1,162 @@
+import typing
+import datetime
+import io
+
+import nyoka.PMML44 as nyoka_pmml  # noqa
+import nyoka.base.constants as nyoka_constants
+
+from .abstract_serializer import AbstractSerializer
+from .. import __version__ as version
+from .. import models as models
+
+
+class NyokaSerializer(AbstractSerializer):
+    APPLICATION_NAME = 'SimpleRuleSetExport'
+    COPYRIGHT_STRING = 'Copyright IBM Corp'
+
+    def __init__(self, timestamp: datetime = None):
+        self._timestamp = timestamp
+
+    def serialize(self, model: typing.Union[models.SimplePMMLRuleSetModel, models.Scorecard]) -> str:
+        if isinstance(model, models.SimplePMMLRuleSetModel):
+            pmml_model = self._nyoka_pmml_model(
+                model,
+                RuleSetModel=None if model.ruleSetModel is None else [self._nyoka_rule_set_model(model.ruleSetModel)])
+        elif isinstance(model, models.Scorecard):
+            pmml_model = self._nyoka_pmml_model(
+                model,
+                Scorecard=None if model is None else [self._nyoka_scorecard_model(model)])
+        else:
+            raise NotImplemented
+        string_io = io.StringIO()
+        pmml_model.export(outfile=string_io, level=0)
+        return string_io.getvalue()
+
+    def _nyoka_pmml_model(
+            self,
+            model: typing.Union[models.SimplePMMLRuleSetModel, models.Scorecard],
+            **build_args
+    ) -> nyoka_pmml.PMML:
+        return nyoka_pmml.PMML(
+            version=nyoka_constants.PMML_SCHEMA.VERSION,
+            Header=nyoka_pmml.Header(
+                copyright=NyokaSerializer.COPYRIGHT_STRING,
+                description=nyoka_constants.HEADER_INFO.DEFAULT_DESCRIPTION,
+                Timestamp=nyoka_pmml.Timestamp(datetime.datetime.now() if self._timestamp is None else self._timestamp),
+                Application=nyoka_pmml.Application(name=NyokaSerializer.APPLICATION_NAME, version=version.version)),
+            DataDictionary=None if model.dataDictionary is None else self._nyoka_data_dictionary(model.dataDictionary),
+            **build_args)
+
+    def _nyoka_data_dictionary(self, data_dictionary: models.DataDictionary) -> nyoka_pmml.DataDictionary:
+        return nyoka_pmml.DataDictionary(
+            numberOfFields=0 if not data_dictionary.dataFields else len(data_dictionary.dataFields),
+            DataField=None if not data_dictionary.dataFields else [
+                self._nyoka_data_field(f) for f in data_dictionary.dataFields])
+
+    def _nyoka_data_field(self, data_field: models.DataField) -> nyoka_pmml.DataField:
+        return nyoka_pmml.DataField(
+            name=data_field.name,
+            optype=data_field.optype.name,
+            dataType=data_field.dataType.name,
+            Value=None if not data_field.values else [
+                nyoka_pmml.Value(value=val.value, property=val.property.name) for val in data_field.values])
+
+    def _nyoka_rule_set_model(self, rule_set_model: models.RuleSetModel) -> nyoka_pmml.RuleSetModel:
+        return nyoka_pmml.RuleSetModel(
+            functionName='classification',
+            algorithmName='RuleSet',
+            MiningSchema=None if rule_set_model.miningSchema is None else self._nyoka_mining_schema(
+                rule_set_model.miningSchema),
+            RuleSet=None if rule_set_model.ruleSet is None else self._nyoka_rule_set(rule_set_model.ruleSet))
+
+    def _nyoka_mining_schema(self, mining_schema: models.MiningSchema) -> nyoka_pmml.MiningSchema:
+        return nyoka_pmml.MiningSchema(
+            MiningField=[
+                nyoka_pmml.MiningField(name=f.name, usageType=f.usageType.name)
+                for f in mining_schema.miningFields])
+
+    def _nyoka_rule_set(self, rule_set: models.RuleSet) -> nyoka_pmml.RuleSet:
+        return nyoka_pmml.RuleSet(
+            RuleSelectionMethod=None if rule_set.ruleSelectionMethod is None else [
+                nyoka_pmml.RuleSelectionMethod(criterion=m.name)
+                for m in rule_set.ruleSelectionMethod],
+            SimpleRule=None if rule_set.rules is None else [self._nyoka_rule(r) for r in rule_set.rules],
+            recordCount=rule_set.recordCount,
+            nbCorrect=rule_set.nbCorrect,
+            defaultScore=rule_set.defaultScore,
+            defaultConfidence=rule_set.defaultConfidence)
+
+    def _nyoka_rule(self, simple_rule: models.SimpleRule) -> nyoka_pmml.SimpleRule:
+        return nyoka_pmml.SimpleRule(
+            SimplePredicate=None if (
+                    simple_rule.predicate is None or not isinstance(simple_rule.predicate, models.SimplePredicate)) else
+            nyoka_pmml.SimplePredicate(
+                field=simple_rule.predicate.field,
+                operator=simple_rule.predicate.operator.name,
+                value=simple_rule.predicate.value),
+            CompoundPredicate=None if (
+                    simple_rule.predicate is None or not isinstance(simple_rule.predicate,
+                                                                    models.CompoundPredicate)) else
+            nyoka_pmml.CompoundPredicate(
+                booleanOperator=simple_rule.predicate.booleanOperator.name,
+                SimplePredicate=[
+                    nyoka_pmml.SimplePredicate(field=sp.field, operator=sp.operator.name, value=sp.value)
+                    for sp in simple_rule.predicate.simplePredicates]),
+            score=simple_rule.score,
+            id=simple_rule.id,
+            recordCount=simple_rule.recordCount,
+            nbCorrect=simple_rule.nbCorrect,
+            confidence=simple_rule.confidence,
+            weight=simple_rule.weight)
+
+    def _nyoka_scorecard_model(self, scorecard: models.Scorecard) -> nyoka_pmml.Scorecard:
+        return nyoka_pmml.Scorecard(
+            functionName='regression',
+            algorithmName='ScoreCard',
+            MiningSchema=None if scorecard.miningSchema is None else self._nyoka_mining_schema(
+                scorecard.miningSchema),
+            initialScore=scorecard.initialScore,
+            useReasonCodes="false",
+            Output=None if scorecard.output is None else nyoka_pmml.Output(
+                OutputField=[
+                    nyoka_pmml.OutputField(
+                        name=outputField.name,
+                        feature=outputField.feature,
+                        dataType=outputField.dataType.name,
+                        optype=outputField.optype.name) for outputField in scorecard.output.outputFields]),
+            Characteristics=None if scorecard.characteristics is None else self._nyoka_pmml_characteristics(
+                scorecard.characteristics))
+
+    def _nyoka_pmml_characteristics(self, characteristics: models.Characteristics) -> nyoka_pmml.Characteristics:
+        return nyoka_pmml.Characteristics(
+            Characteristic=[
+                nyoka_pmml.Characteristic(
+                    name=characteristic.name,
+                    Attribute=[self._nyoka_pmml_attributes(attribute) for attribute in characteristic.attributes])
+                for characteristic in characteristics.characteristics])
+
+    def _nyoka_pmml_attributes(self, attribute: models.Attribute) -> nyoka_pmml.Attribute:
+        return nyoka_pmml.Attribute(
+            partialScore=attribute.score if not isinstance(attribute.score, models.ComplexPartialScore) else None,
+            ComplexPartialScore=nyoka_pmml.ComplexPartialScore(
+                Apply=nyoka_pmml.Apply(
+                    function='+',
+                    Apply_member=[nyoka_pmml.Apply(
+                        function='*',
+                        FieldRef=[nyoka_pmml.FieldRef(field=attribute.score.feature_name)],
+                        Constant=[nyoka_pmml.Constant(valueOf_=attribute.score.multiplier)])],
+                    Constant=[nyoka_pmml.Constant(valueOf_=attribute.score.constant)])) if isinstance(
+                        attribute.score, models.ComplexPartialScore) else None,
+            SimplePredicate=None if (attribute.predicate is None or not isinstance(
+                attribute.predicate, models.SimplePredicate)) else nyoka_pmml.SimplePredicate(
+                    field=attribute.predicate.field,
+                    operator=attribute.predicate.operator.name,
+                    value=attribute.predicate.value),
+            CompoundPredicate=None if (attribute.predicate is None or not isinstance(
+                attribute.predicate, models.CompoundPredicate)) else nyoka_pmml.CompoundPredicate(
+                    booleanOperator=attribute.predicate.booleanOperator.name,
+                    SimplePredicate=[
+                        nyoka_pmml.SimplePredicate(field=sp.field, operator=sp.operator.name, value=sp.value)
+                        for sp in attribute.predicate.simplePredicates]),
+            True_=None if (attribute.predicate is None or not isinstance(
+                attribute.predicate, models.TruePredicate)) else nyoka_pmml.True_())

rulelearn_ri/trxf/scorecard/__init__.py

@@ -0,0 +1,3 @@
+from .bins import LinearIntervalBin, IntervalBin, SetBin, Bin
+from .partition import Partition
+from .scorecard import Scorecard