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

rulelearn_ri/trxf/scorecard/bins.py

@@ -0,0 +1,253 @@
+import abc
+from numbers import Real
+from typing import Dict, Set, Any, Optional
+from rulelearn_ri.trxf.core import Feature
+
+
+class Bin(abc.ABC):
+    """
+    Defines a set of values of interest for a particular feature along with an associated sub-score.
+    """
+
+    def __init__(self, feature: Feature):
+        """
+        @param feature: An instance of trxf.core.Feature. Specifies the feature with which this bin is associated.
+        """
+        self._feature = feature
+
+    @abc.abstractmethod
+    def evaluate(self, assignment: Dict[str, Any]) -> float:
+        """
+        Computes the sub-score for the bin based on the feature value.
+
+        @param assignment: dict mapping variable name to value
+        @return: float sub-score for the bin
+        """
+        raise NotImplementedError('Method evaluate in Bin not implemented')
+
+    @abc.abstractmethod
+    def contains(self, assignment: Dict[str, Any]) -> bool:
+        """
+        Checks if the value of the feature belongs to this bin or not.
+
+        @param assignment: dict mapping variable name to value
+        @return: bool, true if the feature value belongs to the bin and false otherwise
+        """
+        raise NotImplementedError('Method contains in Bin not implemented.')
+
+    @abc.abstractmethod
+    def overlaps(self, other: 'Bin') -> bool:
+        """
+        Checks whether this bin overlaps with the given other bin.
+
+        @param other: An instance of the same class as self specifying the other bin
+        @return: bool, true if the bins share at least one element and false otherwise
+        """
+        raise NotImplementedError('Method overlaps in Bin not implemented.')
+
+    @abc.abstractmethod
+    def __str__(self):
+        raise NotImplementedError('Method __str__ in Bin not implemented.')
+
+    @abc.abstractmethod
+    def __repr__(self):
+        raise NotImplementedError('Method __repr__ in Bin not implemented.')
+
+    @property
+    def feature(self) -> Feature:
+        return self._feature
+
+
+class LinearIntervalBin(Bin):
+    """
+    Defines a Bin specified by a half-open interval [left_end, right_end) where the sub-score is calculated using
+    a linear function of the feature value (requires the feature to evaluate to a numerical value).
+    """
+
+    def __init__(self, feature: Feature, const_part: Real, linear_multiplier: Real, left_end: Optional[Real] = None,
+                 right_end: Optional[Real] = None):
+        """
+        @param feature: An instance of trxf.core.Feature associated with this bin. This must be a numerical feature.
+        @param const_part: The constant additive part used in calculating the sub-score.
+        @param linear_multiplier: The sub-score will be calculated as linear_multiplier * feature_value + const_part
+        @param left_end: The left endpoint of the interval. Set to -infinity if not specified.
+        @param right_end: The right endpoint of the interval. Set to +infinity if not specified.
+        """
+        if left_end is None:
+            left_end = float('-inf')
+        if right_end is None:
+            right_end = float('inf')
+
+        if left_end >= right_end:
+            raise ValueError('Need left_end < right_end but left_end = "{}" and right_end = "{}"'
+                             .format(left_end, right_end))
+
+        super(LinearIntervalBin, self).__init__(feature)
+        self._left_end = left_end
+        self._right_end = right_end
+        self._linear_multiplier = linear_multiplier
+        self._const_part = const_part
+
+    def evaluate(self, assignment: Dict[str, Any]) -> float:
+        """
+        Computes the sub-score for the bin based on the feature value. The sub-score is zero if the feature value lies
+        outside the bin and is given by linear_multiplier * feature_value + const_part otherwise.
+
+        @param assignment: dict mapping variable name to value
+        @return: float sub-score for the bin
+        """
+        if self.contains(assignment):
+            return self.linear_multiplier * self._get_feature_value(assignment) + self.const_part
+        return 0.0
+
+    def contains(self, assignment: Dict[str, Any]) -> bool:
+        """
+        Returns true if left_end <= feature_value < right_end for the given variable assignment.
+
+        @param assignment: dict mapping variable name to value
+        @return: bool True if the feature value belongs to the bin and False otherwise
+        """
+        return self.left_end <= self._get_feature_value(assignment) < self.right_end
+
+    def overlaps(self, other: 'LinearIntervalBin') -> bool:
+        """
+        Checks whether this bin overlaps with the given other bin.
+
+        @param other: An instance of LinearIntervalBin or a subclass thereof
+        @return: bool, true if the bins share at least one element and false otherwise
+        """
+        if not isinstance(other, LinearIntervalBin):
+            raise ValueError('other must be an instance of LinearIntervalBin or a subclass thereof but it'
+                             'is an instance of "{}"'.format(str(other.__class__)))
+        return (self.left_end < other.right_end) and (self.right_end > other.left_end)
+
+    def _get_feature_value(self, assignment: Dict[str, Any]) -> Real:
+        """
+        Evaluates the value of the feature for the specified variable assignment. Raises ValueError if the feature
+        evaluates to a non-numerical value.
+
+        @param assignment: dict mapping variable name to value
+        @return: float, value of the feature
+        """
+        feature_value = self.feature.evaluate(assignment)
+        if isinstance(feature_value, Real):
+            return feature_value
+        raise ValueError('Need the feature to evaluate to a numerical value but the type of returned value is "{}"'
+                         .format(type(feature_value)))
+
+    def __str__(self):
+        return ' '.join([str(self.left_end), '<=', str(self.feature), '<', str(self.right_end), '->',
+                         str(self.linear_multiplier), '*', 'x', '+', str(self.const_part)])
+
+    def __repr__(self):
+        return '%s(%r, [%r, %r), %r * x + %r)' % (self.__class__, self.feature, self.left_end, self.right_end,
+                                                  self.linear_multiplier, self.const_part)
+
+    @property
+    def left_end(self) -> Real:
+        return self._left_end
+
+    @property
+    def right_end(self) -> Real:
+        return self._right_end
+
+    @property
+    def linear_multiplier(self) -> Real:
+        return self._linear_multiplier
+
+    @property
+    def const_part(self) -> Real:
+        return self._const_part
+
+
+class IntervalBin(LinearIntervalBin):
+    """
+    Defines a bin specified by an interval [left_end, right_end) with a constant sub-score
+    """
+
+    def __init__(self, feature: Feature, sub_score: Real, left_end: Optional[Real] = None,
+                 right_end: Optional[Real] = None):
+        """
+        @param feature: An instance of trxf.core.Feature. Specifies the feature to which this bin is associated.
+        @param sub_score: The constant sub-score associated with this bin
+        @param left_end: The left endpoint on the interval. Set to -infinity if not specified.
+        @param right_end: The right endpoint of the interval. Set to +infinity if not specified.
+        """
+        super(IntervalBin, self).__init__(feature, sub_score, 0.0, left_end, right_end)
+
+    def __str__(self):
+        return ' '.join([str(self.left_end), '<=', str(self.feature), '<', str(self.right_end), '->',
+                         str(self.const_part)])
+
+    def __repr__(self):
+        return '%s(%r, [%r, %r), %r)' % (self.__class__, self.feature, self.left_end, self.right_end, self.const_part)
+
+    @property
+    def sub_score(self) -> Real:
+        return self.const_part
+
+
+class SetBin(Bin):
+    """
+    Defines a Bin specified by a finite set of values and a constant sub-score
+    """
+
+    def __init__(self, feature: Feature, sub_score: Real, values: Set[Any]):
+        """
+        @param feature: An instance of trxf.core.Feature. Specifies the feature to which this bin is associated.
+        @param sub_score: The constant sub-score associated with this bin.
+        @param values: The set of values that belong to this bin
+        """
+        if len(values) == 0:
+            raise ValueError('Expected len(values) > 0, received len(values) == "{}"'.format(len(values)))
+
+        super(SetBin, self).__init__(feature)
+        self._values = values
+        self._sub_score = sub_score
+
+    def evaluate(self, assignment: Dict[str, Any]) -> float:
+        """
+        Computes the sub-score for the bin based on the feature value. The sub-score is zero if the feature value lies
+        outside the bin and is given by sub_score otherwise.
+
+        @param assignment: dict mapping variable name to value
+        @return: float sub-score for the bin
+        """
+        if self.contains(assignment):
+            return float(self.sub_score)
+        return 0.0
+
+    def contains(self, assignment: Dict[str, Any]) -> bool:
+        """
+        Returns true if the feature value belongs to the set of values in this bin and false otherwise
+
+        @param assignment: dict mapping variable name to value
+        @return: bool, true if the feature value belongs to the bin and false otherwise
+        """
+        return self.feature.evaluate(assignment) in self.values
+
+    def overlaps(self, other: 'SetBin') -> bool:
+        """
+        Checks whether this bin overlaps with the given other bin.
+
+        @param other: An instance of SetBin or a subclass thereof
+        @return: bool, true if the bins share at least one element and false otherwise
+        """
+        if not isinstance(other, SetBin):
+            raise ValueError('other must be an instance of SetBin or a subclass thereof but it'
+                             'is an instance of "{}"'.format(str(other.__class__)))
+        return len(self.values.intersection(other.values)) > 0
+
+    def __str__(self):
+        return ' '.join([str(self.feature), 'in', str(self.values), '->', str(self.sub_score)])
+
+    def __repr__(self):
+        return '%s(%r, %r, %r)' % (self.__class__, self.feature, self.values, self.sub_score)
+
+    @property
+    def values(self) -> Set[Any]:
+        return self._values
+
+    @property
+    def sub_score(self) -> Real:
+        return self._sub_score

rulelearn_ri/trxf/scorecard/partition.py

@@ -0,0 +1,71 @@
+from typing import List, Dict, Any
+from rulelearn_ri.trxf.core import Feature
+from rulelearn_ri.trxf.scorecard import Bin
+
+
+class Partition(object):
+    """
+    A Partition is a set of non-overlapping bins of the same type associated with the same feature
+    """
+
+    def __init__(self, bins: List[Bin]):
+        """
+        @param bins: A list of instances of a subclass of GeneralizedBin. All elements must have the same type.
+        """
+        if len(bins) == 0:
+            raise ValueError('Need len(bins) > 0 but len(bins) = "{}"'.format(len(bins)))
+
+        # Check that all bins are associated with the same feature and have the same type
+        self._feature = bins[0].feature
+        bin_type = type(bins[0])
+        for idx, curr_bin in enumerate(bins):
+            if curr_bin.feature != self._feature:
+                raise ValueError('All bins must be associated with the same feature but bins[0] was associated with'
+                                 '"{}" whereas bins["{}"] was associated with "{}"'.format(self._feature, idx,
+                                                                                           curr_bin.feature))
+            if type(curr_bin) != bin_type:
+                raise ValueError('All bins must have the same type but bins[0] has type "{}" while bins["{}"]'
+                                 'has type "{}"'.format(bin_type, idx, type(curr_bin)))
+
+        # Check that bins do not overlap
+        for idx1 in range(len(bins)):
+            for idx2 in range(idx1 + 1, len(bins)):
+                if bins[idx1].overlaps(bins[idx2]):
+                    raise ValueError('Bins must be non-overlapping but bin "{}" overlaps with bin "{}"'
+                                     .format(bins[idx1], bins[idx2]))
+
+        self._bins = bins
+
+    def evaluate(self, assignment: Dict[str, Any]) -> float:
+        """
+        Computes the sub-score for the feature associated with this partition. This score is given by the sub-score of
+        the first bin in the partition to which the feature value belongs. Raises ValueError if the feature value does
+        not belong to any of the bins.
+
+        @param assignment: dict mapping variable name to value
+        @return: float sub-score associated with this partition.
+        """
+        for curr_bin in self.bins:
+            if curr_bin.contains(assignment):
+                return curr_bin.evaluate(assignment)
+        raise ValueError('Value "{}" of the feature does not belong to any of the bins'
+                         .format(self._feature.evaluate(assignment)))
+
+    def __str__(self):
+        return '\n'.join([str(self.feature)] + ['\t' + str(curr_bin) for curr_bin in self.bins])
+
+    def __repr__(self):
+        return '\n'.join([str(self.__class__)] + ['\t' + repr(self.feature)] +
+                         ['\t' + repr(curr_bin) for curr_bin in self.bins])
+
+    @property
+    def num_bins(self) -> int:
+        return len(self.bins)
+
+    @property
+    def bins(self) -> List[Bin]:
+        return self._bins
+
+    @property
+    def feature(self) -> Feature:
+        return self._feature

rulelearn_ri/trxf/scorecard/scorecard.py

@@ -0,0 +1,78 @@
+from numbers import Real
+from typing import List, Tuple, Dict, Any
+from rulelearn_ri.trxf.core import Feature
+from rulelearn_ri.trxf.scorecard import Partition
+
+
+class Scorecard(object):
+    """
+    Defines the representation of a scorecard
+    """
+
+    def __init__(self, partitions: List[Partition], bias: Real = 0.0):
+        """
+        @param partitions: A list of instances of class Partition, each specifying the bins for a particular feature.
+                           Elements in the list must correspond to distinct features.
+        @param bias: The global bias term used during scorecard evaluation
+        """
+        if len(partitions) == 0:
+            raise ValueError('Need len(partitions) > 0 but found len(partitions) == "{}"'.format(len(partitions)))
+
+        # Check that all partitions use different features
+        seen = []
+        for idx, partition in enumerate(partitions):
+            try:
+                prev_idx = seen.index(partition.feature)
+            except ValueError:
+                seen.append(partition.feature)
+                continue
+            raise ValueError('The instances in partitions must correspond to distinct features but the instance'
+                             'at index "{}" and "{}" use the same feature "{}"'
+                             .format(prev_idx, idx, partition.feature))
+
+        self._partitions = partitions
+        self._bias = bias
+
+    def evaluate(self, assignment: Dict[str, Any]) -> float:
+        """
+        Computes the output of the scorecard for the given assignment of variables. This output is computed as the
+        sum of sub-scores for each partition in the scorecard and the bias term.
+
+        @param assignment: dict mapping variable names to values
+        @return: float score computed using the scorecard
+        """
+        score = self.bias
+        for partition in self.partitions:
+            score += partition.evaluate(assignment)
+        return float(score)
+
+    def __str__(self):
+        return '\n'.join([str(partition) for partition in self.partitions] + ['Bias="{}"'.format(self.bias)])
+
+    def __repr__(self):
+        return '\n'.join([str(self.__class__)] + [repr(partition) for partition in self.partitions] +
+                         ['Bias="{}"'.format(self.bias)])
+
+    @property
+    def bias(self) -> Real:
+        return self._bias
+
+    @property
+    def partitions(self) -> List[Partition]:
+        return self._partitions
+
+    @property
+    def features(self) -> List[Feature]:
+        return [partition.feature for partition in self.partitions]
+
+    @property
+    def num_features(self) -> int:
+        return len(self.partitions)
+
+    @property
+    def bins_per_feature(self) -> List[Tuple[Feature, int]]:
+        return [(partition.feature, partition.num_bins) for partition in self.partitions]
+
+    @property
+    def total_bins(self) -> int:
+        return sum([partition.num_bins for partition in self.partitions])

rulelearn_ripper_interactive-0.2.3.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: rulelearn-ripper-interactive
+Version: 0.2.3
+Summary: Rule induction toolkit (fork of IBM rulelearn) with interactive, constrained single-rule RIPPER optimization
+Author-email: Aaron Kurz <aaron.kurz@unisg.ch>, Hagen Voelzer <hagen.voelzer@unisg.ch>
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/aaronkurz/rulelearn-ripper-interactive
+Project-URL: Upstream, https://github.com/IBM/rulelearn
+Keywords: rule induction,ripper,interpretable machine learning,explainability,rule learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: numba
+Requires-Dist: nyoka==5.4.0
+Provides-Extra: rbm
+Requires-Dist: cvxpy; extra == "rbm"
+Requires-Dist: ecos; extra == "rbm"
+Requires-Dist: matplotlib; extra == "rbm"
+Provides-Extra: r2n
+Requires-Dist: torch; extra == "r2n"
+Provides-Extra: all
+Requires-Dist: rulelearn-ripper-interactive[r2n,rbm]; extra == "all"
+Dynamic: license-file
+
+# rulelearn-ripper-interactive
+
+A rule induction toolkit for learning readable, editable rules from data. It is a fork of
+[IBM's rulelearn](https://github.com/IBM/rulelearn) that adds **interactive, constrained
+single-rule optimization** for RIPPER. You can grow and prune a single conjunctive rule
+while forcing some features or predicates into it and keeping others out.
+
+The package installs as `rulelearn_ri`, so it can be installed side by side with the
+upstream `rulelearn` package.
+
+## Installation
+
+```bash
+pip install rulelearn-ripper-interactive
+```
+
+or, to add it to a [uv](https://docs.astral.sh/uv/) project:
+
+```bash
+uv add rulelearn-ripper-interactive
+```
+
+The core install covers RIPPER and TRXF (rule interchange, metrics and PMML export).
+The other algorithms need heavier dependencies, available as extras:
+
+```bash
+pip install "rulelearn-ripper-interactive[rbm]"   # BRCG / GLRM (cvxpy, ecos, matplotlib)
+pip install "rulelearn-ripper-interactive[r2n]"   # Relational Rule Network (torch)
+pip install "rulelearn-ripper-interactive[all]"   # everything
+```
+
+With uv, use `uv add "rulelearn-ripper-interactive[rbm]"` (or `[r2n]`, `[all]`) instead.
+
+Requires Python 3.10 or newer.
+
+## Single-rule optimization
+
+`optimize_single_rule` learns one conjunctive rule for a target label and returns it as a
+TRXF `Conjunction`:
+
+```python
+import pandas as pd
+from rulelearn_ri.algorithms.ripper import optimize_single_rule
+
+df = pd.DataFrame({
+    'x': [1.0, 2.0, 3.0, 4.0],
+    'target': ['True', 'True', 'False', 'False'],
+})
+X, y = df.drop(columns='target'), df['target']
+
+rule = optimize_single_rule(X, y, target_label='True')
+print(rule)
+```
+
+Constraints let you steer the rule:
+
+```python
+from rulelearn_ri.trxf.core import Feature, Predicate, Relation
+
+# Force the feature `x` to appear in the rule (the boundary is still optimized)
+optimize_single_rule(X, y, target_label='True', fixed_attributes=['x'])
+
+# Force a specific predicate, with a fixed boundary, into the rule
+optimize_single_rule(
+    X, y, target_label='True',
+    fixed_predicates=[Predicate(Feature('x'), Relation.LE, 2.5)],
+)
+
+# Keep a feature out of the rule (must not clash with any forced feature or predicate)
+optimize_single_rule(X, y, target_label='True', forbidden_attributes=['x'])
+```
+
+Further options: `pruning_threshold` (minimum number of instances for the grow/prune
+split, default 20), `random_state` (seed for the split, default 0) and `ratio`
+(fraction of the data used for growing, default 2/3).
+
+## Included algorithms
+
+- Fast Effective Rule Induction (RIPPER) ([William W Cohen, 1995](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.2612&rep=rep1&type=pdf)),
+  including the full rule-set learner `RipperExplainer`
+- Boolean Decision Rules via Column Generation (Light Edition) ([Dash et al., 2018](https://papers.nips.cc/paper/7716-boolean-decision-rules-via-column-generation)), extra `rbm`
+- Generalized Linear Rule Models ([Wei et al., 2019](http://proceedings.mlr.press/v97/wei19a.html)), extra `rbm`
+- Relational Rule Network (R2N) ([Kusters et al., 2022](https://arxiv.org/abs/2201.06515)), extra `r2n`
+- TRXF (Technical Rule Interchange Format): a common rule-set representation with evaluation tools
+  and PMML export
+
+Example notebooks are in the [`examples/`](https://github.com/aaronkurz/rulelearn-ripper-interactive/tree/main/examples) directory of the repository.
+
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/):
+
+```bash
+git clone git@github.com:aaronkurz/rulelearn-ripper-interactive.git
+cd rulelearn-ripper-interactive
+uv sync --all-extras
+uv run pytest
+```
+
+### Releasing
+
+1. Bump `version` in `pyproject.toml`.
+2. Build and check the distributions:
+   ```bash
+   rm -rf dist && uv build
+   uvx twine check --strict dist/*
+   ```
+3. Upload to TestPyPI first, then check it installs in a clean environment:
+   ```bash
+   uv publish --publish-url https://test.pypi.org/legacy/ --token <testpypi-token>
+   ```
+4. Upload to PyPI and tag the release:
+   ```bash
+   uv publish --token <pypi-token>
+   git tag v<version> && git push origin v<version>
+   ```
+
+## Acknowledgements
+
+This package is derived from [rulelearn](https://github.com/IBM/rulelearn) by IBM,
+originally released as part of [AI Explainability 360](https://github.com/Trusted-AI/AIX360).
+See [NOTICE](https://github.com/aaronkurz/rulelearn-ripper-interactive/blob/main/NOTICE) for details.
+
+## License
+
+Apache License 2.0. See [LICENSE](https://github.com/aaronkurz/rulelearn-ripper-interactive/blob/main/LICENSE).

rulelearn_ripper_interactive-0.2.3.dist-info/RECORD

@@ -0,0 +1,73 @@
+rulelearn_ri/__init__.py,sha256=jNP9W3mpGoFFPe7vGg37q3mIj8dJr4NsRQUUXUkS-2g,163
+rulelearn_ri/dise.py,sha256=kwQOoUQE6xqqInANdwD5X3KIMAhXuYaSWVMRZLzcsgk,1988
+rulelearn_ri/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rulelearn_ri/algorithms/r2n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rulelearn_ri/algorithms/r2n/base.py,sha256=DoXsmM3t6PdEGDEWi5qrNnGn5b4gtq0HpTMleZNZw84,1017
+rulelearn_ri/algorithms/r2n/functions.py,sha256=NqX1kcT1tUeBchfuA-SymD6ZGs1kTjKbtTIqGNAcJDs,682
+rulelearn_ri/algorithms/r2n/mask.py,sha256=GWjw8oFQ2kFmbtCY3ozSU31Fk6GnUk4nnD-C3FWZmoI,1595
+rulelearn_ri/algorithms/r2n/preprocessing_layers.py,sha256=8zYlw-T3d-CrugmqjVDfQf64cHG8omzZkP439WrIsuI,6971
+rulelearn_ri/algorithms/r2n/r2n_algo.py,sha256=eGv1V6tAbGPTOwcupQL7Nmo-Fleh1F6HBiTm5RmEPPI,12690
+rulelearn_ri/algorithms/r2n/simple_rulenet.py,sha256=GNHeSQoAXst2Do-AYxtl0a95sZuA0jY563VTNsLNeoM,2547
+rulelearn_ri/algorithms/r2n/training.py,sha256=jxMDM_H6wipd8TF1wnEEjfbMWfcXIFKklR7gQtC3E4w,1085
+rulelearn_ri/algorithms/r2n/utilities.py,sha256=E5wd3BW1umu4tlv8ENm1NAWbxzWCRvOSb_lTjNMzKdY,4251
+rulelearn_ri/algorithms/rbm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rulelearn_ri/algorithms/rbm/boolean_rule_cg.py,sha256=ipntWEQt5_hFyLwCBjUcydVZB47vfP3Nt26Mtu-QKII,2224
+rulelearn_ri/algorithms/rbm/utils.py,sha256=bluMLTwFTKd_ai1Pu2nBI6-hYC4Mqxuj-kXFEFq3r1c,315
+rulelearn_ri/algorithms/rbm/rbm/BRCG.py,sha256=e8BfIEm9B9QIn8dlZs-4X2cXwfZoKoIHGunGTixXn74,2522
+rulelearn_ri/algorithms/rbm/rbm/GLRM.py,sha256=tg_8C8HA5_bWQlX4p7xNNfVCFBw5xtdM4F49axrPqqI,3739
+rulelearn_ri/algorithms/rbm/rbm/__init__.py,sha256=fMtOjJTkGbYsd8yOPDkgRzXx068O5eg7T1_UyK_Qye4,281
+rulelearn_ri/algorithms/rbm/rbm/beam_search.py,sha256=KjKDw-ye5KiTveDIfUw60msmjJlmW9TFTPAnqNcLG6o,13057
+rulelearn_ri/algorithms/rbm/rbm/boolean_rule_cg.py,sha256=x5pwI9k_Kri26Z8j3R85dADNvXMgb8hXd9bvI_3yqLY,9907
+rulelearn_ri/algorithms/rbm/rbm/features.py,sha256=FtYZEYtlVrSd7sIIiZqQ0wIElQkyJWi2IE1i_CgENpw,24215
+rulelearn_ri/algorithms/rbm/rbm/linear_regression.py,sha256=_-bZzAM8zg1OWb73xkeXemFxA9LUzKELapgLxaBO_A0,17602
+rulelearn_ri/algorithms/rbm/rbm/logistic_regression.py,sha256=Omlpzj9diHMAmCNcV1sxYwzwmhodZeZBjNAJ1M2Gweo,19789
+rulelearn_ri/algorithms/ripper/__init__.py,sha256=j4kVSsvxKRss9nMppbcQxpqD-fXibDTTwT9PdzIs8HM,228
+rulelearn_ri/algorithms/ripper/base.py,sha256=2tS0hmm5E-EEJPouXrlln78zJoI8L2FR7NHD1ce0jGM,2764
+rulelearn_ri/algorithms/ripper/binding.py,sha256=aAx70HKYFAIccA1j7KmEP_Xqvj0m4WgDyqQZxMknCWc,11920
+rulelearn_ri/algorithms/ripper/mdl.py,sha256=Npg5ycPpWPk9JonMfPoezPrNsHL1osNdZo5tNwNchKk,2015
+rulelearn_ri/algorithms/ripper/pruning.py,sha256=7Po1puPJpufREwY6sLfkS6FEaOj2rXRWzWpUrfgrTT8,4456
+rulelearn_ri/algorithms/ripper/ripper.py,sha256=D3qCbwMWE7jkjwvp31k10T8nIieqbI4hey5ufCHu89Q,21564
+rulelearn_ri/algorithms/ripper/ripper_ruleset_generator.py,sha256=Snz5gJ457m4JDx5d_FQAb_BPmopmtnNmpUv7QkltNuQ,902
+rulelearn_ri/algorithms/ripper/single_rule.py,sha256=HEx_rITY100d15Xim9QIwdjPytSjwQjIPHWSIl0-O_w,16221
+rulelearn_ri/trxf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rulelearn_ri/trxf/metrics.py,sha256=JEkfVrnxbeUAHqW5uZ-70iZ34e6vQqCTS63oMRS8o7c,4265
+rulelearn_ri/trxf/classifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rulelearn_ri/trxf/classifier/ruleset_classifier.py,sha256=6lLz8siaiaOJ6Ks9Z0l-RuoPt7_n0J2QLLT_L1AyOp4,6282
+rulelearn_ri/trxf/core/__init__.py,sha256=jBMUQkndUnDU72BxsM49zh8JCb9gkepZcAhsxzlXsEA,193
+rulelearn_ri/trxf/core/boolean_evaluator.py,sha256=MpDnozNaDoCd2cckawFW5AEzj78jgctgNmhPHlAsVTY,397
+rulelearn_ri/trxf/core/conjunction.py,sha256=VaWUK7e5EmWhbpHiCmmnzjJBO4BsC5FmFKZO64QSW54,1539
+rulelearn_ri/trxf/core/dnf_ruleset.py,sha256=QluNdrkL7r6BigXCsfc4gsVSutzW4T1alviXmAP74G0,2317
+rulelearn_ri/trxf/core/feature.py,sha256=kQ8O1ECUubjNvr4mbQ6QgWdWP4M168rF-itZf6twXDk,5255
+rulelearn_ri/trxf/core/predicate.py,sha256=KNChRF2Q5yy7iwTtMj_D7thijZgob68UyXLrbmbM2QM,3162
+rulelearn_ri/trxf/core/ruleset_generator.py,sha256=DCF2PrbTgwCx0o06IFR3hBTKWxbLH5CkbmB7_bCCGaE,816
+rulelearn_ri/trxf/core/utils.py,sha256=vqJXV0Tt8vQEcPOY065jCgQlzkpy6iuGt1OAsZsFU9A,1245
+rulelearn_ri/trxf/pmml_export/__init__.py,sha256=6CZ_EJzb3kGIs7gpq5XAlHsVQFEF9r_UuBYqJXe_PmY,180
+rulelearn_ri/trxf/pmml_export/__version__.py,sha256=p6UlmKJFsYomZzmxB_Ks3LTBru51FpBAY_hQw9_jogY,18
+rulelearn_ri/trxf/pmml_export/pmml_exporter.py,sha256=h612wn9wzQC49T5me3lZg5lhQ8xxHHXZAtkvjCAkb80,782
+rulelearn_ri/trxf/pmml_export/models/__init__.py,sha256=eKRbZhTx88mHsDGTI3QkR1D8RKulegYF5I-hniMWMGs,981
+rulelearn_ri/trxf/pmml_export/models/attribute.py,sha256=-oI9pnx0vbnTlUzkIW1vBjnSa2D5ZYxeVIoN76vwIrE,617
+rulelearn_ri/trxf/pmml_export/models/characteristics.py,sha256=5TWHHdfbrPvlL7h9BSUxfiN0y8VxUS3IZDj51onr3vE,381
+rulelearn_ri/trxf/pmml_export/models/data_dictionary.py,sha256=tj7eGXqM3rg2LiiJEyL5SMPXOflwNo4QJxqZrcaCccs,1123
+rulelearn_ri/trxf/pmml_export/models/mining_schema.py,sha256=riUUs2Z93NbxGt087VrNKmON79re2jsAwQjSDkx1fiw,554
+rulelearn_ri/trxf/pmml_export/models/pmml_ruleset_model.py,sha256=6VZK4Acr0qzIOlS0QIxZT5hAbqbHEl-u9FeuyJQqx2g,435
+rulelearn_ri/trxf/pmml_export/models/predicate.py,sha256=IHN9T3BjnUzABK3479wxzryu1LbnyB6Ly35QTvf5Nyg,965
+rulelearn_ri/trxf/pmml_export/models/rule.py,sha256=SAgvKsv4R30eKeSJxskWtzKPCxPr2lazxLri4ZeNGfc,805
+rulelearn_ri/trxf/pmml_export/models/ruleset.py,sha256=P3aBgYZ4p5EqWl4V7iu4RsICvoo7Gw4m35PtFh1yMu4,763
+rulelearn_ri/trxf/pmml_export/models/ruleset_model.py,sha256=UsdesNQGj5NxK1HfNbN6HhsrJj2_nDhWYfPxO0-n23Y,396
+rulelearn_ri/trxf/pmml_export/models/scorecard.py,sha256=cvJj6jPhSsSbJw-sQVP2kd1xZPEnb_SkPIsJosXox4Q,799
+rulelearn_ri/trxf/pmml_export/reader/__init__.py,sha256=2woCITEi5QaUrmrCzVqcsEY6ntnLrYYXqciJo7U799c,80
+rulelearn_ri/trxf/pmml_export/reader/abstract_reader.py,sha256=qPcbytFtzjZTQF4XFrAxS8AyKDcC5SCOw4Icw9hD3sE,311
+rulelearn_ri/trxf/pmml_export/reader/trxf_reader.py,sha256=8sXWEKqBkObrj64s7dUt7nLT_XQXwO3Xn7JZqtKQi5M,5567
+rulelearn_ri/trxf/pmml_export/serializer/__init__.py,sha256=NqjAw_feiNUUm0d4X2ZgjcMQzIO3F3xOyTkE00SH9B8,98
+rulelearn_ri/trxf/pmml_export/serializer/abstract_serializer.py,sha256=qiNH4oYHnDzkUxYyLhRHfr92ln4rDfJ4Y3mQapcgeEM,246
+rulelearn_ri/trxf/pmml_export/serializer/nyoka_serializer.py,sha256=NyWBDD3GTtjR9mNGLVrawNZsv3CN-TL4nVipA889Kks,8848
+rulelearn_ri/trxf/scorecard/__init__.py,sha256=VeDCZDno8xpRrajbUt19ptz5egsdykjloy4oXhLaZT0,128
+rulelearn_ri/trxf/scorecard/bins.py,sha256=Sm_hKfQcUSTfFJRkf-KX8WbNf-ajOBT4qKwHIQCCimc,10335
+rulelearn_ri/trxf/scorecard/partition.py,sha256=4LyEZJvnenJmsb21NsyL5C9XiRFHlOyPNVdGkorSxjg,3097
+rulelearn_ri/trxf/scorecard/scorecard.py,sha256=Y-Fa-5hrqEKcnIP4bCYdGxg3GQ9iio1tmaEBJy80LQI,2942
+rulelearn_ripper_interactive-0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rulelearn_ripper_interactive-0.2.3.dist-info/licenses/NOTICE,sha256=BcNidS_aDOBStBdw7jUKMWqT56Md-7NEU8qDhPBWfRE,494
+rulelearn_ripper_interactive-0.2.3.dist-info/METADATA,sha256=0ksyaCeKnfzYBvbaP5NS-mFbP7d_heIg4TCzouhh6sc,6116
+rulelearn_ripper_interactive-0.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+rulelearn_ripper_interactive-0.2.3.dist-info/top_level.txt,sha256=Skh2-5pMO7dqQWvCJk_gDP3JkVz8EuX0cH5oLrfXiv8,13
+rulelearn_ripper_interactive-0.2.3.dist-info/RECORD,,

rulelearn_ripper_interactive-0.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+