RuleTree 0.0.2.post1__tar.gz

ruletree-0.0.2.post1/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2016, PackageOwner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ruletree-0.0.2.post1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include requirements.txt
+include README.md

ruletree-0.0.2.post1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: ruletree
+Version: 0.0.2.post1
+Summary: Package description
+Home-page: https://github.com/riccotti/RuleTree
+Author: Cristiano Landi
+Author-email: cristiano.landi@phd.unipi.it
+License: BSD-Clause-2
+Keywords: keyword1 keyword2 keyword3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX :: Other
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.0.0
+Requires-Dist: scikit-learn>=1.5.0
+Requires-Dist: scikit-learn-extra
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: category_encoders
+Requires-Dist: threadpoolctl
+Requires-Dist: tqdm
+Requires-Dist: progress-table
+Requires-Dist: pygraphviz
+Requires-Dist: graphviz>=0.20.3
+Requires-Dist: numba
+Requires-Dist: psutil
+Requires-Dist: setuptools
+Requires-Dist: matplotlib
+Requires-Dist: tempfile312
+Provides-Extra: flag
+
+# RuleTree
+TODO

ruletree-0.0.2.post1/README.md

@@ -0,0 +1,2 @@
+# RuleTree
+TODO

ruletree-0.0.2.post1/RuleTree/__init__.py

@@ -0,0 +1,9 @@
+from ruletree.tree.RuleTreeRegressor import RuleTreeRegressor
+from ruletree.tree.RuleTreeClassifier import RuleTreeClassifier
+from ruletree.tree.RuleTreeCluster import RuleTreeCluster, RuleTreeClusterRegressor, RuleTreeClusterClassifier
+
+from ruletree.ensemble.RuleForestRegressor import RuleForestRegressor
+from ruletree.ensemble.RuleForestClassifier import RuleForestClassifier
+from ruletree.ensemble.RuleTreeAdaBoostRegressor import RuleTreeAdaBoostRegressor
+from ruletree.ensemble.RuleTreeAdaBoostClassifier import RuleTreeAdaBoostClassifier
+

ruletree-0.0.2.post1/RuleTree/base/RuleTreeBase.py

@@ -0,0 +1,7 @@
+from abc import ABC
+
+from sklearn.base import BaseEstimator
+
+
+class RuleTreeBase(BaseEstimator, ABC):
+    pass

ruletree-0.0.2.post1/RuleTree/base/RuleTreeBaseSplit.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class RuleTreeBaseSplit(ABC):
+    @abstractmethod
+    def __init__(self, ml_task):
+        self.ml_task = ml_task

ruletree-0.0.2.post1/RuleTree/base/RuleTreeBaseStump.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+
+from sklearn.base import BaseEstimator
+
+from ruletree.utils.define import DATA_TYPE_TABULAR
+
+
+class RuleTreeBaseStump(BaseEstimator, ABC):
+    @abstractmethod
+    def get_rule(self, columns_names=None, scaler=None, float_precision:int|None=3):
+        pass
+
+    @abstractmethod
+    def node_to_dict(self):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def dict_to_node(self, node_dict, X):
+        pass
+
+    @staticmethod
+    def supports(data_type):
+        return data_type in [DATA_TYPE_TABULAR]

ruletree-0.0.2.post1/RuleTree/ensemble/RuleForestClassifier.py

@@ -0,0 +1,233 @@
+from random import random
+import numpy as np
+import sklearn.base
+from sklearn.ensemble import BaggingClassifier
+from ruletree.utils.data_utils import _iterative_mean
+
+from ruletree import RuleTreeClassifier
+from ruletree.base.RuleTreeBase import RuleTreeBase
+from sklearn.base import ClassifierMixin
+
+from ruletree.stumps.classification.MultiplePivotTreeStumpClassifier import MultiplePivotTreeStumpClassifier
+from ruletree.stumps.classification.ObliquePivotTreeStumpClassifier import ObliquePivotTreeStumpClassifier
+from ruletree.stumps.classification.PivotTreeStumpClassifier import PivotTreeStumpClassifier
+
+
+class RuleForestClassifier(BaggingClassifier, RuleTreeBase):
+    def __init__(self,
+                 n_estimators=100,
+                 criterion='gini',
+                 max_depth=None,
+                 min_samples_split=2,
+                 min_samples_leaf=1,
+                 min_weight_fraction_leaf=0.0,
+                 min_impurity_decrease=0.0,
+                 max_leaf_nodes=float("inf"),
+                 class_weight=None,
+                 ccp_alpha=0.0,
+                 prune_useless_leaves=False,
+                 splitter='best',
+                 *,
+                 max_samples=None,
+                 max_features=1.0,
+                 bootstrap=True,
+                 oob_score=False,
+                 warm_start=False,
+                 custom_estimator:sklearn.base.ClassifierMixin=None,
+                 n_jobs=None,
+                 random_state=None,
+                 base_stump = None,
+                 distance_matrix = None,
+                 distance_measure = None,
+                 stump_selection = 'best',
+                 verbose=0):
+        
+        self.n_estimators = n_estimators
+        self.criterion = criterion
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.min_impurity_decrease = min_impurity_decrease
+        self.max_leaf_nodes = max_leaf_nodes
+        self.class_weight = class_weight
+        self.ccp_alpha = ccp_alpha
+        self.prune_useless_leaves = prune_useless_leaves
+        self.splitter = splitter
+        self.max_samples = max_samples
+        self.max_features = max_features
+        self.bootstrap = bootstrap
+        self.oob_score = oob_score
+        self.warm_start = warm_start
+        self.custom_estimator = custom_estimator
+        self.n_jobs = n_jobs
+        self.random_state = random_state
+        self.verbose = verbose
+        self.base_stump = base_stump
+        self.distance_matrix = distance_matrix
+        self.distance_measure = distance_measure
+        self.stump_selection= stump_selection
+               
+
+    def fit(self, X:np.ndarray, y:np.ndarray, sample_weight=None, **kwargs):
+        if self.max_features is None:
+            self.max_features = X.shape[1]
+
+        if type(self.max_features) is str:
+            if self.max_features == "sqrt":
+                self.max_features = int(np.sqrt(X.shape[1]))
+            elif self.max_features == "log2":
+                self.max_features = int(np.log2(X.shape[1]))
+
+        base_estimator = RuleTreeClassifier if self.custom_estimator is None else self.custom_estimator
+        splitter = .5 if self.splitter == 'hybrid_forest' else self.splitter
+        if type(splitter) is float:
+            base_estimator = RuleTreeClassifier_choosing_splitter_randomly
+            
+        if self.base_stump is not None:
+            if any(isinstance(clf, (PivotTreeStumpClassifier, ObliquePivotTreeStumpClassifier, MultiplePivotTreeStumpClassifier)) for clf in self.base_stump):
+                base_estimator = ForestEstimatorPivotClassifier
+
+        super().__init__(estimator=base_estimator(criterion=self.criterion,
+                                                  max_depth=self.max_depth,
+                                                  min_samples_split=self.min_samples_split,
+                                                  min_samples_leaf=self.min_samples_leaf,
+                                                  min_weight_fraction_leaf=self.min_weight_fraction_leaf,
+                                                  min_impurity_decrease=self.min_impurity_decrease,
+                                                  random_state=self.random_state,
+                                                  max_leaf_nodes=self.max_leaf_nodes,
+                                                  class_weight=self.class_weight,
+                                                  ccp_alpha=self.ccp_alpha,
+                                                  prune_useless_leaves=self.prune_useless_leaves,
+                                                  splitter=self.splitter,
+                                                  base_stump = self.base_stump,
+                                                  distance_measure = self.distance_measure,
+                                                  distance_matrix = self.distance_matrix,
+                                                  stump_selection= self.stump_selection
+                        
+                                                  ),
+                         n_estimators=self.n_estimators,
+                         max_samples=X.shape[0] if self.max_samples is None else self.max_samples,
+                         max_features=self.max_features,
+                         bootstrap=self.bootstrap,
+                         bootstrap_features=True,
+                         oob_score=self.oob_score,
+                         warm_start=self.warm_start,
+                         n_jobs=self.n_jobs,
+                         random_state=self.random_state,
+                         verbose=self.verbose)
+
+        return super().fit(X, y, sample_weight=sample_weight, **kwargs)
+     
+    def local_interpretation(self, X, joint_contribution = False):
+        
+        if joint_contribution:
+            biases = []
+            contributions = []
+            predictions = []
+            
+            for tree in self.estimators_:
+                pred, bias, contribution = tree.local_interpretation(X, joint_contribution=joint_contribution)
+                biases.append(bias)
+                contributions.append(contribution)
+                predictions.append(pred)
+                
+            total_contributions = []
+            
+            for i in range(len(X)):
+                contr = {}
+                for j, dct in enumerate(contributions):
+                    for k in set(dct[i]).union(set(contr.keys())):
+                        contr[k] = (contr.get(k, 0)*j + dct[i].get(k,0) ) / (j+1)
+
+                total_contributions.append(contr)    
+                
+            for i, item in enumerate(contribution):
+                total_contributions[i]
+                sm = sum([v for v in contribution[i].values()])
+                    
+
+            
+            return (np.mean(predictions, axis=0), np.mean(biases, axis=0),
+                total_contributions)
+        else:
+            mean_pred = None
+            mean_bias = None
+            mean_contribution = None
+            
+            for i, tree in enumerate(self.estimators_):
+                pred, bias, contribution = tree.local_interpretation(X)
+                
+                if i < 1: # first iteration
+                    mean_bias = bias
+                    mean_contribution = contribution
+                    mean_pred = pred
+                else:
+                    mean_bias = _iterative_mean(i, mean_bias, bias)
+                    mean_contribution = _iterative_mean(i, mean_contribution, contribution)
+                    mean_pred = _iterative_mean(i, mean_pred, pred)
+
+            return mean_pred, mean_bias, mean_contribution
+
+        
+
+class RuleTreeClassifier_choosing_splitter_randomly(RuleTreeClassifier):
+    def __init__(self, splitter, **kwargs):
+        if random() < splitter:
+            if random() < splitter:
+                splitter = 'random'
+            else:
+                splitter = 'best'
+        kwargs["splitter"] = splitter
+        super().__init__(**kwargs)
+        
+class ForestEstimatorPivotClassifier(RuleTreeClassifier):
+    def __init__(self,
+                 max_leaf_nodes=float('inf'),
+                 min_samples_split=2,
+                 max_depth=float('inf'),
+                 prune_useless_leaves=False,
+                 base_stump: ClassifierMixin | list = None,
+                 stump_selection: str = 'random',
+                 random_state=None,
+
+                 criterion='gini',
+                 splitter='best',
+                 min_samples_leaf=1,
+                 min_weight_fraction_leaf=0.0,
+                 max_features=None,
+                 min_impurity_decrease=0.0,
+                 class_weight=None,
+                 ccp_alpha=0.0,
+                 monotonic_cst=None,
+                 distance_matrix = None,
+                 distance_measure = None
+                 
+                 ):
+        
+        super().__init__(max_leaf_nodes=max_leaf_nodes,
+                         min_samples_split=min_samples_split,
+                         max_depth=max_depth,
+                         prune_useless_leaves=prune_useless_leaves,
+                         base_stump=base_stump,
+                         stump_selection=stump_selection,
+                         random_state=random_state)
+
+        self.max_depth = max_depth
+        self.criterion = criterion
+        self.splitter = splitter
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.max_features = max_features
+        self.random_state = random_state
+        self.min_impurity_decrease = min_impurity_decrease
+        self.class_weight = class_weight
+        self.ccp_alpha = ccp_alpha
+        self.monotonic_cst = monotonic_cst
+        self.distance_matrix = distance_matrix    
+        self.distance_measure = distance_measure
+
+    
+    def fit(self, X: np.array, y: np.array=None, **kwargs):
+        super().fit(X, y, **kwargs)

ruletree-0.0.2.post1/RuleTree/ensemble/RuleForestRegressor.py

@@ -0,0 +1,103 @@
+from random import random
+
+import numpy as np
+import sklearn
+from sklearn.ensemble import BaggingRegressor
+
+from ruletree import RuleTreeRegressor
+from ruletree.base.RuleTreeBase import RuleTreeBase
+
+
+class RuleForestRegressor(BaggingRegressor, RuleTreeBase):
+    def __init__(self,
+                 n_estimators=100,
+                 criterion='squared_error',
+                 max_depth=None,
+                 min_samples_split=2,
+                 min_samples_leaf=1,
+                 min_weight_fraction_leaf=0.0,
+                 min_impurity_decrease=0.0,
+                 max_leaf_nodes=float("inf"),
+                 ccp_alpha=0.0,
+                 prune_useless_leaves=False,
+                 splitter='best',
+                 *,
+                 max_samples=None,
+                 max_features=1.0,
+                 bootstrap=True,
+                 oob_score=False,
+                 warm_start=False,
+                 custom_estimator: sklearn.base.RegressorMixin = None,
+                 n_jobs=None,
+                 random_state=None,
+                 verbose=0):
+        self.n_estimators = n_estimators
+        self.criterion = criterion
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.min_impurity_decrease = min_impurity_decrease
+        self.max_leaf_nodes = max_leaf_nodes
+        self.ccp_alpha = ccp_alpha
+        self.prune_useless_leaves = prune_useless_leaves
+        self.splitter = splitter
+
+        self.max_samples = max_samples
+        self.max_features = max_features
+        self.bootstrap = bootstrap
+        self.oob_score = oob_score
+        self.warm_start = warm_start
+        self.custom_estimator = custom_estimator
+        self.n_jobs = n_jobs
+        self.random_state = random_state
+        self.verbose = verbose
+
+    def fit(self, X:np.ndarray, y:np.ndarray, sample_weight=None):
+        if self.max_features is None:
+            self.max_features = X.shape[1]
+
+        if type(self.max_features) is str:
+            if self.max_features == "sqrt":
+                self.max_features = int(np.sqrt(X.shape[1]))
+            elif self.max_features == "log2":
+                self.max_features = int(np.log2(X.shape[1]))
+
+        base_estimator = RuleTreeRegressor if self.custom_estimator is None else self.custom_estimator
+        splitter = .5 if self.splitter == 'hybrid_forest' else self.splitter
+        if type(splitter) is float:
+            base_estimator = RuleTreeRegressor_choosing_splitter_randomly
+
+        super().__init__(estimator=base_estimator(criterion=self.criterion,
+                                                  max_depth=self.max_depth,
+                                                  min_samples_split=self.min_samples_split,
+                                                  min_samples_leaf=self.min_samples_leaf,
+                                                  min_weight_fraction_leaf=self.min_weight_fraction_leaf,
+                                                  min_impurity_decrease=self.min_impurity_decrease,
+                                                  max_leaf_nodes=self.max_leaf_nodes,
+                                                  ccp_alpha=self.ccp_alpha,
+                                                  prune_useless_leaves=self.prune_useless_leaves,
+                                                  splitter=self.splitter
+                                                  ),
+                         n_estimators=self.n_estimators,
+                         max_samples=X.shape[0] if self.max_samples is None else self.max_samples,
+                         max_features=self.max_features,
+                         bootstrap=self.bootstrap,
+                         bootstrap_features=True,
+                         oob_score=self.oob_score,
+                         warm_start=self.warm_start,
+                         n_jobs=self.n_jobs,
+                         random_state=self.random_state,
+                         verbose=self.verbose)
+
+        return super().fit(X, y, sample_weight=sample_weight)
+
+class RuleTreeRegressor_choosing_splitter_randomly(RuleTreeRegressor):
+    def __init__(self, splitter, **kwargs):
+        if random() < splitter:
+            if random() < splitter:
+                splitter = 'random'
+            else:
+                splitter = 'best'
+        kwargs["splitter"] = splitter
+        super().__init__(**kwargs)

ruletree-0.0.2.post1/RuleTree/ensemble/RuleTreeAdaBoostClassifier.py

@@ -0,0 +1,61 @@
+from sklearn.ensemble import AdaBoostClassifier
+
+from ruletree import RuleTreeClassifier
+from ruletree.base.RuleTreeBase import RuleTreeBase
+
+
+class RuleTreeAdaBoostClassifier(AdaBoostClassifier, RuleTreeBase):
+    def __init__(self,
+                 n_estimators=50,
+                 min_samples_split=2,
+                 prune_useless_leaves=False,
+                 random_state=None,
+                 criterion='gini',
+                 splitter='best',
+                 min_samples_leaf=1,
+                 min_weight_fraction_leaf=0.0,
+                 max_features=None,
+                 min_impurity_decrease=0.0,
+                 class_weight=None,
+                 ccp_alpha=0.0,
+                 monotonic_cst=None,
+                 *,
+                 learning_rate=1.0,
+                 algorithm='SAMME'
+                 ):
+        self.min_samples_split = min_samples_split
+        self.prune_useless_leaves = prune_useless_leaves
+        self.random_state = random_state
+        self.criterion = criterion
+        self.splitter = splitter
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.max_features = max_features
+        self.min_impurity_decrease = min_impurity_decrease
+        self.class_weight = class_weight
+        self.ccp_alpha = ccp_alpha
+        self.monotonic_cst = monotonic_cst
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.algorithm = algorithm
+
+        estimator = RuleTreeClassifier(min_samples_split=min_samples_split,
+                                         max_depth=3, #stump
+                                         prune_useless_leaves=prune_useless_leaves,
+                                         random_state=random_state,
+
+                                         criterion=criterion,
+                                         splitter=splitter,
+                                         min_samples_leaf=min_samples_leaf,
+                                         min_weight_fraction_leaf=min_weight_fraction_leaf,
+                                         max_features=max_features,
+                                         min_impurity_decrease=min_impurity_decrease,
+                                         class_weight=class_weight,
+                                         ccp_alpha=ccp_alpha,
+                                         monotonic_cst=monotonic_cst
+                                         )
+
+        super().__init__(
+            estimator=estimator,
+            n_estimators=n_estimators, learning_rate=learning_rate, algorithm=algorithm, random_state=random_state
+        )

ruletree-0.0.2.post1/RuleTree/ensemble/RuleTreeAdaBoostRegressor.py

@@ -0,0 +1,54 @@
+from sklearn.ensemble import AdaBoostRegressor
+
+from ruletree import RuleTreeRegressor
+from ruletree.base.RuleTreeBase import RuleTreeBase
+
+
+class RuleTreeAdaBoostRegressor(AdaBoostRegressor, RuleTreeBase):
+    def __init__(self,
+                 n_estimators=50,
+                 min_samples_split=2,
+                 prune_useless_leaves=False,
+                 random_state=None,
+                 criterion='squared_error',
+                 splitter='best',
+                 min_samples_leaf=1,
+                 min_weight_fraction_leaf=0.0,
+                 max_features=None,
+                 min_impurity_decrease=0.0,
+                 ccp_alpha=0.0,
+                 monotonic_cst=None,
+                 *,
+                 learning_rate=1.0,
+                 loss='linear'
+                 ):
+        self.min_samples_split = min_samples_split
+        self.prune_useless_leaves = prune_useless_leaves
+        self.random_state = random_state
+        self.criterion = criterion
+        self.splitter = splitter
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.max_features = max_features
+        self.min_impurity_decrease = min_impurity_decrease
+        self.ccp_alpha = ccp_alpha
+        self.monotonic_cst = monotonic_cst
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.loss = loss
+
+        super().__init__(
+            estimator=RuleTreeRegressor(max_depth=1, #stump
+                                        prune_useless_leaves=prune_useless_leaves,
+                                        random_state=random_state,
+                                        criterion=criterion,
+                                        splitter=splitter,
+                                        min_samples_leaf=min_samples_leaf,
+                                        min_weight_fraction_leaf=min_weight_fraction_leaf,
+                                        max_features=max_features,
+                                        min_impurity_decrease=min_impurity_decrease,
+                                        ccp_alpha=ccp_alpha,
+                                        monotonic_cst=monotonic_cst
+                                        ),
+            n_estimators=n_estimators, learning_rate=learning_rate, loss=loss, random_state=random_state
+        )