psyke 0.4.9.dev6__py3-none-any.whl → 1.0.4.dev10__py3-none-any.whl

psyke/extraction/cart/CartPredictor.py

@@ -0,0 +1,128 @@
+from collections.abc import Iterable
+from typing import Union, Any
+import numpy as np
+import pandas as pd
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from tuprolog.core import clause, Var, Struct
+from tuprolog.theory import Theory, mutable_theory
+
+from psyke.extraction.cart import LeafConstraints, LeafSequence
+from psyke.schema import LessThan, GreaterThan, SchemaException, DiscreteFeature
+from psyke.utils.logic import create_variable_list, create_head, create_term
+
+
+class CartPredictor:
+    """
+    A wrapper for decision and regression trees of sklearn.
+    """
+
+    def __init__(self, predictor: Union[DecisionTreeClassifier, DecisionTreeRegressor] = DecisionTreeClassifier(),
+                 discretization=None, normalization=None):
+        self._predictor = predictor
+        self.discretization = discretization
+        self.normalization = normalization
+
+    def __get_constraints(self, nodes: Iterable[tuple[int, bool]]) -> LeafConstraints:
+        thresholds = [self._predictor.tree_.threshold[i[0]] for i in nodes]
+        features = [self._predictor.feature_names_in_[self._predictor.tree_.feature[node[0]]] for node in nodes]
+        conditions = [node[1] for node in nodes]
+        if self.normalization is not None:
+            thresholds = [threshold * self.normalization[feature][1] + self.normalization[feature][0]
+                          for feature, threshold in zip(features, thresholds)]
+        cond_dict = {}
+        for feature, condition, threshold in zip(features, conditions, thresholds):
+            cond = LessThan(threshold) if condition else GreaterThan(threshold)
+            if feature in cond_dict:
+                try:
+                    cond_dict[feature][-1] *= cond
+                except SchemaException:
+                    cond_dict[feature].append(cond)
+            else:
+                cond_dict[feature] = [cond]
+        return cond_dict
+
+    def __get_leaves(self) -> Iterable[int]:
+        return [i for i, (left_child, right_child) in enumerate(zip(
+            self._left_children, self._right_children
+        )) if left_child == -1 and right_child == -1]
+
+    def __get_prediction(self, node: int) -> Any:
+        if hasattr(self._predictor, 'classes_'):
+            return self._predictor.classes_[np.argmax(self._predictor.tree_.value[node])]
+        else:
+            return self._predictor.tree_.value[node]
+
+    def __path(self, node: int, path=None) -> Iterable[tuple[int, bool]]:
+        path = [] if path is None else path
+        if node == 0:
+            return path
+        father = list(self._left_children if node in self._left_children else self._right_children).index(node)
+        return self.__path(father, [(father, node in self._left_children)] + path)
+
+    def __iter__(self) -> LeafSequence:
+        leaves = self.__get_leaves()
+        return ((self.__get_constraints(self.__path(i)), self.__get_prediction(i)) for i in leaves)
+
+    def predict(self, data) -> Iterable:
+        return self._predictor.predict(data)
+
+    @staticmethod
+    def _simplify_nodes(nodes: list) -> Iterable:
+        simplified = [nodes.pop(0)]
+        while len(nodes) > 0:
+            first_node = nodes[0][0]
+            for k, conditions in first_node.items():
+                for condition in conditions:
+                    if all(k in node[0] and condition in node[0][k] for node in nodes):
+                        [node[0][k].remove(condition) for node in nodes]
+            simplified.append(nodes.pop(0))
+        return [({k: v for k, v in rule.items() if v != []}, prediction) for rule, prediction in simplified]
+
+    def _create_body(self, variables: dict[str, Var], conditions: LeafConstraints) -> Iterable[Struct]:
+        results = []
+        for feature_name, cond_list in conditions.items():
+            for condition in cond_list:
+                feature: DiscreteFeature = [d for d in self.discretization if feature_name in d.admissible_values][0] \
+                    if self.discretization else None
+                results.append(create_term(variables[feature_name], condition) if feature is None else
+                               create_term(variables[feature.name],
+                                           feature.admissible_values[feature_name],
+                                           isinstance(condition, GreaterThan)))
+        return results
+
+    def create_theory(self, data: pd.DataFrame, simplify: bool = True) -> Theory:
+        new_theory = mutable_theory()
+        nodes = [node for node in self]
+        nodes = self._simplify_nodes(nodes) if simplify else nodes
+        for (constraints, prediction) in nodes:
+            if self.normalization is not None and data.columns[-1] in self.normalization:
+                m, s = self.normalization[data.columns[-1]]
+                prediction = prediction * s + m
+            variables = create_variable_list(self.discretization, data)
+            new_theory.assertZ(
+                clause(
+                    create_head(data.columns[-1], list(variables.values()), prediction),
+                    self._create_body(variables, constraints)
+                )
+            )
+        return new_theory
+
+    @property
+    def predictor(self) -> Union[DecisionTreeClassifier, DecisionTreeRegressor]:
+        return self._predictor
+
+    @property
+    def n_leaves(self) -> int:
+        return len(list(self.__get_leaves()))
+
+    @property
+    def _left_children(self) -> list[int]:
+        return self._predictor.tree_.children_left
+
+    @property
+    def _right_children(self) -> list[int]:
+        return self._predictor.tree_.children_right
+
+    @predictor.setter
+    def predictor(self, predictor: Union[DecisionTreeClassifier, DecisionTreeRegressor]):
+        self._predictor = predictor

psyke/extraction/cart/FairTree.py

@@ -0,0 +1,205 @@
+import numpy as np
+from collections import Counter
+
+from sklearn.metrics import accuracy_score, r2_score
+
+
+class Node:
+    def __init__(self, feature=None, threshold=None, left=None, right=None, *, value=None):
+        self.feature = feature
+        self.threshold = threshold
+        self.left = left
+        self.right = right
+        self.value = value
+
+    def is_leaf_node(self):
+        return self.value is not None
+
+
+class FairTree:
+    def __init__(self, max_depth=3, max_leaves=None, criterion=None, min_samples_split=2, lambda_penalty=0.0,
+                 protected_attr=None):
+        self.max_depth = max_depth
+        self.max_leaves = max_leaves
+        self.min_samples_split = min_samples_split
+        self.lambda_penalty = lambda_penalty
+        self.protected_attr = protected_attr
+        self.criterion = criterion
+        self.root = None
+        self.n_leaves = 0
+        self.quality_function = None
+
+    def fit(self, X, y):
+        self.n_leaves = 0
+        self.root = self._grow_tree(X, y, depth=0)
+        while self.n_leaves > self.max_leaves:
+            self.prune_least_important_leaf(X, y)
+            self.n_leaves -= 1
+        return self
+
+    @staticmethod
+    def _estimate_output(y):
+        raise NotImplementedError
+
+    def score(self, X, y):
+        raise NotImplementedError
+
+    def predict(self, X):
+        return np.array([self._traverse_tree(x, self.root) for _, x in X.iterrows()])
+
+    def _traverse_tree(self, x, node):
+        if node.is_leaf_node():
+            return node.value
+        if x[node.feature] <= node.threshold:
+            return self._traverse_tree(x, node.left)
+        return self._traverse_tree(x, node.right)
+
+    def _grow_tree(self, X, y, depth):
+        if depth >= self.max_depth or X.shape[0] < self.min_samples_split or len(set(y.values.flatten())) == 1 or \
+                (self.max_leaves is not None and self.n_leaves >= self.max_leaves):
+            self.n_leaves += 1
+            return Node(value=self._estimate_output(y))
+
+        best_feature, best_threshold = self._best_split(X, y)
+        if best_feature is None:
+            self.n_leaves += 1
+            return Node(value=self._estimate_output(y))
+
+        left_idxs = X[best_feature] <= best_threshold
+        right_idxs = X[best_feature] > best_threshold
+
+        left = self._grow_tree(X[left_idxs], y[left_idxs], depth + 1)
+        right = self._grow_tree(X[right_idxs], y[right_idxs], depth + 1)
+        return Node(best_feature, best_threshold, left, right)
+
+    @staticmethod
+    def generate_thresholds(X, y):
+        sorted_indices = np.argsort(X)
+        X = np.array(X)[sorted_indices]
+        y = np.array(y)[sorted_indices]
+        # X = np.array(np.unique(np.unique(list(zip(X, y)), axis=0)[:, 0]), dtype=float)
+        return np.array([(X[:-1][i] + X[1:][i]) / 2.0 for i in range(len(X) - 1) if y[i] != y[i + 1]])
+
+    def _best_split(self, X, y):
+        best_gain = -float('inf')
+        split_idx, split_threshold = None, None
+
+        for feature in [feature for feature in X.columns if feature not in self.protected_attr]:
+            # for threshold in self.generate_thresholds(X[feature], y):
+            for threshold in np.unique(np.quantile(X[feature], np.linspace(0, 1, num=25))):
+                left_idxs = X[feature] <= threshold
+                right_idxs = X[feature] > threshold
+
+                if left_idxs.sum() == 0 or right_idxs.sum() == 0:
+                    continue
+
+                gain = self._fair_gain(y, left_idxs, right_idxs, X[self.protected_attr])
+
+                if gain > best_gain:
+                    best_gain = gain
+                    split_idx = feature
+                    split_threshold = threshold
+        return split_idx, split_threshold
+
+    @staticmethod
+    def _disparity(group):
+        counts = Counter(group)
+        if len(counts) <= 1:
+            return 0.0
+        values = np.array(list(counts.values())) / len(group)
+        return np.abs(values[0] - values[1])
+
+    def _fair_gain(self, y, left_idx, right_idx, protected):
+        child = len(y[left_idx]) / len(y) * self.quality_function(y[left_idx]) + \
+                len(y[right_idx]) / len(y) * self.quality_function(y[right_idx])
+        info_gain = self.quality_function(y) - child
+        penalty = self._disparity(protected[left_idx]) + self._disparity(protected[right_idx])
+        return info_gain - self.lambda_penalty * penalty
+
+    @staticmethod
+    def _match_path(x, path):
+        for node, left in path:
+            if left and x[node.feature] > node.threshold:
+                return False
+            if not left and x[node.feature] <= node.threshold:
+                return False
+        return True
+
+    @staticmethod
+    def candidates(node, parent=None, is_left=None, path=[]):
+        if node is None or node.is_leaf_node():
+            return []
+        leaves = []
+        if node.left.is_leaf_node() and node.right.is_leaf_node():
+            leaves.append((node, parent, is_left, path))
+        leaves += FairTreeClassifier.candidates(node.left, node, True, path + [(node, True)])
+        leaves += FairTreeClassifier.candidates(node.right, node, False, path + [(node, False)])
+        return leaves
+
+    def prune_least_important_leaf(self, X, y):
+        best_score = -np.inf
+        best_prune = None
+
+        for node, parent, is_left, path in self.candidates(self.root):
+            original_left = node.left
+            original_right = node.right
+
+            merged_y = y[(X.apply(lambda x: self._match_path(x, path), axis=1))]
+            if len(merged_y) == 0:
+                continue
+            new_value = self._estimate_output(merged_y)
+            node.left = node.right = None
+            node.value = new_value
+
+            score = self.score(X, y)
+            if score >= best_score:
+                best_score = score
+                best_prune = (node, new_value)
+
+            node.left, node.right, node.value = original_left, original_right, None
+
+        if best_prune:
+            best_prune[0].left = best_prune[0].right = None
+            best_prune[0].value = best_prune[1]
+
+
+class FairTreeClassifier(FairTree):
+    def __init__(self, max_depth=3, max_leaves=None, criterion='entropy', min_samples_split=2, lambda_penalty=0.0,
+                 protected_attr=None):
+        super().__init__(max_depth, max_leaves, criterion, min_samples_split, lambda_penalty, protected_attr)
+        self.quality_function = self._gini if self.criterion == 'gini' else self._entropy
+
+    @staticmethod
+    def _estimate_output(y):
+        return Counter(y.values.flatten()).most_common(1)[0][0]
+
+    def score(self, X, y):
+        return accuracy_score(y.values.flatten(), self.predict(X))
+
+    @staticmethod
+    def _entropy(y):
+        ps = np.unique(y, return_counts=True)[1] / len(y)
+        return -np.sum([p * np.log2(p) for p in ps if p > 0])
+
+    @staticmethod
+    def _gini(y):
+        return 1.0 - np.sum(np.unique(y, return_counts=True)[1] / len(y)**2)
+
+
+class FairTreeRegressor(FairTree):
+    def __init__(self, max_depth=3, max_leaves=None, criterion='mse', min_samples_split=2, lambda_penalty=0.0,
+                 protected_attr=None):
+        super().__init__(max_depth, max_leaves, criterion, min_samples_split, lambda_penalty, protected_attr)
+        self.quality_function = self._mse
+
+    @staticmethod
+    def _estimate_output(y):
+        return np.mean(y.values.flatten())
+
+    def score(self, X, y):
+        return r2_score(y.values.flatten(), self.predict(X))
+
+    @staticmethod
+    def _mse(y):
+        y = y.values.flatten().astype(float)
+        return np.mean((y - np.mean(y))**2)

psyke/extraction/cart/FairTreePredictor.py

@@ -0,0 +1,56 @@
+import copy
+from typing import Union, Any
+
+from psyke.extraction.cart import FairTreeClassifier, FairTreeRegressor, LeafSequence, LeafConstraints
+from psyke.extraction.cart.CartPredictor import CartPredictor
+from psyke.schema import LessThan, GreaterThan, SchemaException, Value
+
+
+class FairTreePredictor(CartPredictor):
+    """
+    A wrapper for fair decision and regression trees of psyke.
+    """
+
+    def __init__(self, predictor: Union[FairTreeClassifier, FairTreeRegressor] = FairTreeClassifier(),
+                 discretization=None, normalization=None):
+        super().__init__(predictor, discretization, normalization)
+
+    def __iter__(self) -> LeafSequence:
+        leaves = [node for node in self.recurse(self._predictor.root, {})]
+        return (leaf for leaf in leaves)
+
+    @staticmethod
+    def merge_constraints(constraints: LeafConstraints, constraint: Value, feature: str):
+        if feature in constraints:
+            try:
+                constraints[feature][-1] *= constraint
+            except SchemaException:
+                constraints[feature].append(constraint)
+        else:
+            constraints[feature] = [constraint]
+        return constraints
+
+    def recurse(self, node, constraints) -> Union[LeafSequence, tuple[LeafConstraints, Any]]:
+        if node.is_leaf_node():
+            return constraints, node.value
+
+        feature = node.feature
+        threshold = node.threshold if self.normalization is None else \
+            (node.threshold * self.normalization[feature][1] + self.normalization[feature][0])
+
+        left = self.recurse(node.left, self.merge_constraints(copy.deepcopy(constraints), LessThan(threshold), feature))
+        right = self.recurse(node.right, self.merge_constraints(copy.deepcopy(constraints),
+                                                                GreaterThan(threshold), feature))
+        return (left if isinstance(left, list) else [left]) + (right if isinstance(right, list) else [right])
+
+    @property
+    def predictor(self) -> Union[FairTreeClassifier, FairTreeRegressor]:
+        return self._predictor
+
+    @property
+    def n_leaves(self) -> int:
+        return self._predictor.n_leaves
+
+    @predictor.setter
+    def predictor(self, predictor: Union[FairTreeClassifier, FairTreeRegressor]):
+        self._predictor = predictor

psyke/extraction/cart/__init__.py

@@ -1,84 +1,70 @@
+from abc import ABC
+
 from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
-from psyke.extraction.cart.predictor import CartPredictor, LeafConstraints, LeafSequence
-from psyke import get_default_random_seed, PedagogicalExtractor
-from psyke.schema import GreaterThan, DiscreteFeature
-from psyke.utils.logic import create_variable_list, create_head, create_term
-from tuprolog.core import clause, Var, Struct
-from tuprolog.theory import Theory, mutable_theory
-from typing import Iterable
+
+from psyke.extraction import PedagogicalExtractor
+from psyke import get_default_random_seed
+from psyke.extraction.cart.FairTree import FairTreeClassifier, FairTreeRegressor
+from psyke.schema import DiscreteFeature, Value
+from tuprolog.theory import Theory
+from typing import Iterable, Any
 import pandas as pd
 
 
 TREE_SEED = get_default_random_seed()
 
+LeafConstraints = dict[str, list[Value]]
+LeafSequence = Iterable[tuple[LeafConstraints, Any]]
+
 
-class Cart(PedagogicalExtractor):
+class Cart(PedagogicalExtractor, ABC):
 
-    def __init__(self, predictor, max_depth: int = 3, max_leaves: int = None,
+    def __init__(self, predictor, max_depth: int = 3, max_leaves: int = None, max_features=None,
                  discretization: Iterable[DiscreteFeature] = None,
                  normalization=None, simplify: bool = True):
+        from psyke.extraction.cart.CartPredictor import CartPredictor
+
         super().__init__(predictor, discretization, normalization)
-        self._cart_predictor = CartPredictor(normalization=normalization)
+        self.is_fair = None
+        self._cart_predictor = CartPredictor(discretization=discretization, normalization=normalization)
         self.depth = max_depth
         self.leaves = max_leaves
+        self.max_features = max_features
         self._simplify = simplify
 
-    def _create_body(self, variables: dict[str, Var], constraints: LeafConstraints) -> Iterable[Struct]:
-        results = []
-        for feature_name, constraint, value in constraints:
-            features = [d for d in self.discretization if feature_name in d.admissible_values]
-            feature: DiscreteFeature = features[0] if len(features) > 0 else None
-            results.append(create_term(variables[feature_name], constraint) if feature is None else
-                           create_term(variables[feature.name],
-                                       feature.admissible_values[feature_name],
-                                       isinstance(constraint, GreaterThan)))
-        return results
+    def _extract(self, data: pd.DataFrame) -> Theory:
+        from psyke.extraction.cart.FairTreePredictor import FairTreePredictor
 
-    @staticmethod
-    def _simplify_nodes(nodes: list) -> Iterable:
-        simplified = [nodes.pop(0)]
-        while len(nodes) > 0:
-            first_node = nodes[0][0]
-            for condition in first_node:
-                if all([condition in [node[0] for node in nodes][i] for i in range(len(nodes))]):
-                    [node[0].remove(condition) for node in nodes]
-            simplified.append(nodes.pop(0))
-        return simplified
+        if self.is_fair:
+            self._cart_predictor = FairTreePredictor(discretization=self.discretization,
+                                                     normalization=self.normalization)
+            fair_tree = FairTreeClassifier if isinstance(data.iloc[0, -1], str) else FairTreeRegressor
+            self._cart_predictor.predictor = fair_tree(max_depth=self.depth, max_leaves=self.leaves,
+                                                       protected_attr=self.is_fair)
+        else:
+            tree = DecisionTreeClassifier if isinstance(data.iloc[0, -1], str) else DecisionTreeRegressor
+            self._cart_predictor.predictor = tree(random_state=TREE_SEED, max_depth=self.depth,
+                                                  max_leaf_nodes=self.leaves, max_features=self.max_features)
+        self._cart_predictor.predictor.fit(data.iloc[:, :-1], data.iloc[:, -1])
+        return self._cart_predictor.create_theory(data, self._simplify)
 
-    def _create_theory(self, data: pd.DataFrame, mapping: dict[str: int], sort: bool = True) -> Theory:
-        new_theory = mutable_theory()
-        nodes = [node for node in self._cart_predictor]
-        nodes = Cart._simplify_nodes(nodes) if self._simplify else nodes
-        for (constraints, prediction) in nodes:
-            if self.normalization is not None:
-                m, s = self.normalization[data.columns[-1]]
-                prediction = prediction * s + m
-            if mapping is not None and prediction in mapping.values():
-                for k, v in mapping.items():
-                    if v == prediction:
-                        prediction = k
-                        break
-            variables = create_variable_list(self.discretization, data, sort)
-            new_theory.assertZ(
-                clause(
-                    create_head(data.columns[-1], list(variables.values()), prediction),
-                    self._create_body(variables, constraints)
-                )
-            )
-        return new_theory
+    def make_fair(self, features: Iterable[str]):
+        self.is_fair = features
 
-    def _extract(self, data: pd.DataFrame, mapping: dict[str: int] = None, sort: bool = True) -> Theory:
-        self._cart_predictor.predictor = DecisionTreeClassifier(random_state=TREE_SEED) \
-            if isinstance(data.iloc[0, -1], str) or mapping is not None else DecisionTreeRegressor(random_state=TREE_SEED)
-        if mapping is not None:
-            data.iloc[:, -1] = data.iloc[:, -1].apply(lambda x: mapping[x] if x in mapping.keys() else x)
-        self._cart_predictor.predictor.max_depth = self.depth
-        self._cart_predictor.predictor.max_leaf_nodes = self.leaves
-        self._cart_predictor.predictor.fit(data.iloc[:, :-1], data.iloc[:, -1])
-        return self._create_theory(data, mapping, sort)
+    def _predict(self, dataframe: pd.DataFrame) -> Iterable:
+        return self._cart_predictor.predict(dataframe)
 
-    def _predict(self, data) -> Iterable:
-        return self._cart_predictor.predict(data)
+    def predict_why(self, data: dict[str, float], verbose=True):
+        prediction = None
+        conditions = {}
+        if self.normalization is not None:
+            data = {k: v * self.normalization[k][1] + self.normalization[k][0] if k in self.normalization else v
+                    for k, v in data.items()}
+        for conditions, prediction in self._cart_predictor:
+            if all(all(interval.is_in(data[variable]) for interval in intervals)
+                   for variable, intervals in conditions.items()):
+                break
+        return prediction, conditions
 
     @property
     def n_rules(self) -> int: