psyke 0.9.0__tar.gz → 0.9.1__tar.gz

{psyke-0.9.0/psyke.egg-info → psyke-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.9.0
+Version: 0.9.1
 Summary: Python-based implementation of PSyKE, i.e. a Platform for Symbolic Knowledge Extraction
 Home-page: https://github.com/psykei/psyke-python
 Author: Matteo Magnini

psyke-0.9.1/VERSION

@@ -0,0 +1 @@
+0.9.1

psyke-0.9.1/psyke/extraction/__init__.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from collections import Iterable
+
+import pandas as pd
+from tuprolog.theory import Theory
+
+from psyke import Extractor
+
+
+class PedagogicalExtractor(Extractor, ABC):
+
+    def __init__(self, predictor, discretization=None, normalization=None):
+        Extractor.__init__(self, predictor=predictor, discretization=discretization, normalization=normalization)
+
+    def _substitute_output(self, dataframe: pd.DataFrame) -> pd.DataFrame:
+        new_y = pd.DataFrame(self.predictor.predict(dataframe.iloc[:, :-1])).set_index(dataframe.index)
+        data = dataframe.iloc[:, :-1].copy().join(new_y)
+        data.columns = dataframe.columns
+        return data
+
+    def extract(self, dataframe: pd.DataFrame) -> Theory:
+        self.theory = self._extract(self._substitute_output(dataframe))
+        return self.theory
+
+    def _extract(self, dataframe: pd.DataFrame) -> Theory:
+        raise NotImplementedError('extract')

{psyke-0.9.0 → psyke-0.9.1}/psyke/extraction/cart/FairTree.py

@@ -72,12 +72,20 @@ class FairTree:
         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]
+        return np.array([(X[i] + X[i - 1]) / 2.0 for i in range(1, len(X)) 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 np.unique(np.quantile(X[feature], np.linspace(0, 1, num=25))):
+            # for threshold in np.unique(np.quantile(X[feature], np.linspace(0, 1, num=25))):
+            for threshold in self.generate_thresholds(X[feature], y):
                 left_idxs = X[feature] <= threshold
                 right_idxs = X[feature] > threshold
 

{psyke-0.9.0 → psyke-0.9.1}/psyke/extraction/cart/FairTreePredictor.py

@@ -1,15 +1,9 @@
 import copy
-from collections import Iterable
 from typing import Union, Any
-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 FairTreeClassifier, FairTreeRegressor, LeafSequence, LeafConstraints
 from psyke.extraction.cart.CartPredictor import CartPredictor
-from psyke.schema import LessThan, GreaterThan, SchemaException, DiscreteFeature, Value
-from psyke.utils.logic import create_variable_list, create_head, create_term
+from psyke.schema import LessThan, GreaterThan, SchemaException, Value
 
 
 class FairTreePredictor(CartPredictor):
@@ -17,7 +11,7 @@ class FairTreePredictor(CartPredictor):
     A wrapper for fair decision and regression trees of psyke.
     """
 
-    def __init__(self, predictor: Union[FairTreeClassifier, FairTreeRegressor] = DecisionTreeClassifier(),
+    def __init__(self, predictor: Union[FairTreeClassifier, FairTreeRegressor] = FairTreeClassifier(),
                  discretization=None, normalization=None):
         super().__init__(predictor, discretization, normalization)
 

{psyke-0.9.0 → psyke-0.9.1}/psyke/extraction/real/__init__.py

@@ -19,6 +19,7 @@ class REAL(PedagogicalExtractor):
 
     def __init__(self, predictor, discretization: Iterable[DiscreteFeature]):
         super().__init__(predictor, discretization)
+        self._ignore_feature = []
         self._ruleset: IndexedRuleSet = IndexedRuleSet()
 
     @property
@@ -87,13 +88,20 @@ class REAL(PedagogicalExtractor):
         return self._create_ruleset(dataset)
 
     def _internal_predict(self, sample: pd.Series):
-        x = [index for index, rule in self._ruleset.flatten() if REAL._rule_from_example(sample) in rule]
+        x = [index for index, rule in self._ruleset.flatten() if self._rule_from_example(sample) in rule]
         return x[0] if x else None
 
-    @staticmethod
-    def _rule_from_example(sample: pd.Series) -> Rule:
+    def make_fair(self, features: Iterable[str]):
+        self._ignore_feature = [list(i.admissible_values.keys()) for i in self.discretization if i.name in features] \
+            if self.discretization else [features]
+        self._ignore_feature = [feature for features in self._ignore_feature for feature in features]
+        self._get_or_set.cache_clear()
+
+    def _rule_from_example(self, sample: pd.Series) -> Rule:
         true_predicates, false_predicates = [], []
         for feature, value in sample.items():
+            if feature in self._ignore_feature:
+                continue
             true_predicates.append(str(feature)) if value == 1 else false_predicates.append(str(feature))
         return Rule(true_predicates, false_predicates)
 

{psyke-0.9.0 → psyke-0.9.1}/psyke/extraction/trepan/__init__.py

@@ -15,11 +15,17 @@ class Trepan(PedagogicalExtractor):
     def __init__(self, predictor, discretization: Iterable[DiscreteFeature], min_examples: int = 0, max_depth: int = 3,
                  split_logic: SplitLogic = SplitLogic.DEFAULT):
         super().__init__(predictor, discretization)
+        self._ignore_feature = []
         self.min_examples = min_examples
         self.max_depth = max_depth
         self.split_logic = split_logic
         self._root: Node
 
+    def make_fair(self, features: Iterable[str]):
+        self._ignore_feature = [list(i.admissible_values.keys()) for i in self.discretization if i.name in features] \
+            if self.discretization else [features]
+        self._ignore_feature = [feature for features in self._ignore_feature for feature in features]
+
     @property
     def n_rules(self):
         return sum(1 for _ in self._root)
@@ -29,7 +35,7 @@ class Trepan(PedagogicalExtractor):
             raise NotImplementedError()
         if node.n_classes == 1:
             return None
-        splits = Trepan._create_splits(node, names)
+        splits = self._create_splits(node, names)
         return None if len(splits) == 0 or splits[0].children[0].depth > self.max_depth else splits[0].children
 
     def _compact(self):
@@ -55,22 +61,20 @@ class Trepan(PedagogicalExtractor):
     def _create_split(node: Node, column: str) -> Union[Split, None]:
         true_examples = Trepan._create_samples(node, column, 1.0)
         false_examples = Trepan._create_samples(node, column, 0.0)
-        true_constrains = list(node.constraints) + [(column, 1.0)]
-        false_constrains = list(node.constraints) + [(column, 0.0)]
-        true_node = Node(true_examples, node.n_examples, true_constrains, depth=node.depth + 1)\
+        true_constraints = list(node.constraints) + [(column, 1.0)]
+        false_constraints = list(node.constraints) + [(column, 0.0)]
+        true_node = Node(true_examples, node.n_examples, true_constraints, depth=node.depth + 1) \
             if true_examples.shape[0] > 0 else None
-        false_node = Node(false_examples, node.n_examples, false_constrains, depth=node.depth + 1)\
+        false_node = Node(false_examples, node.n_examples, false_constraints, depth=node.depth + 1) \
             if false_examples.shape[0] > 0 else None
         return None if true_node is None or false_node is None else Split(node, (true_node, false_node))
 
-    @staticmethod
-    def _create_splits(node: Node, names: Iterable[str]) -> SortedList[Split]:
-        splits, constrains = Trepan._init_splits(node)
-        for column in names:
-            if column not in constrains:
-                split = Trepan._create_split(node, column)
-                if split is not None:
-                    splits.add(split)
+    def _create_splits(self, node: Node, names: Iterable[str]) -> SortedList[Split]:
+        splits, constraints = Trepan._init_splits(node)
+        for column in [column for column in names if column not in list(constraints) + self._ignore_feature]:
+            split = Trepan._create_split(node, column)
+            if split is not None:
+                splits.add(split)
         return splits
 
     def _create_theory(self, name: str) -> MutableTheory:

{psyke-0.9.0 → psyke-0.9.1/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.9.0
+Version: 0.9.1
 Summary: Python-based implementation of PSyKE, i.e. a Platform for Symbolic Knowledge Extraction
 Home-page: https://github.com/psykei/psyke-python
 Author: Matteo Magnini

psyke-0.9.0/VERSION

@@ -1 +0,0 @@
-0.9.0

psyke-0.9.0/psyke/extraction/__init__.py

@@ -1,51 +0,0 @@
-from abc import ABC
-from collections import Iterable
-
-import pandas as pd
-from tuprolog.theory import Theory
-
-from psyke import Extractor
-
-
-class PedagogicalExtractor(Extractor, ABC):
-
-    def __init__(self, predictor, discretization=None, normalization=None):
-        Extractor.__init__(self, predictor=predictor, discretization=discretization, normalization=normalization)
-
-    def _substitute_output(self, dataframe: pd.DataFrame) -> pd.DataFrame:
-        new_y = pd.DataFrame(self.predictor.predict(dataframe.iloc[:, :-1])).set_index(dataframe.index)
-        data = dataframe.iloc[:, :-1].copy().join(new_y)
-        data.columns = dataframe.columns
-        return data
-
-    def extract(self, dataframe: pd.DataFrame) -> Theory:
-        self.theory = self._extract(self._substitute_output(dataframe))
-        return self.theory
-
-    def _extract(self, dataframe: pd.DataFrame) -> Theory:
-        raise NotImplementedError('extract')
-
-
-class FairExtractor(PedagogicalExtractor, ABC):
-
-    def __init__(self, extractor: Extractor, features: Iterable):
-        super().__init__(extractor.predictor, extractor.discretization, extractor.normalization)
-        self.features = features
-        self.extractor = extractor
-        # self.make_fair()
-
-#    def extract(self, dataframe: pd.DataFrame) -> Theory:
-#        self.theory = self.extractor.extract(dataframe)
-#        return self.theory
-
-#    def predict_why(self, data: dict[str, float], verbose: bool = True):
-#        self.extractor.predict_why(data, verbose)
-
-#    def predict_counter(self, data: dict[str, float], verbose: bool = True, only_first: bool = True):
-#        self.extractor.predict_counter(data, verbose, only_first)
-
-#    def _predict(self, dataframe: pd.DataFrame) -> Iterable:
-#        return self.extractor.predict(dataframe)
-
-#    def _brute_predict(self, dataframe: pd.DataFrame, criterion: str = 'corner', n: int = 2) -> Iterable:
-#        return self.extractor.brute_predict(dataframe, criterion, n)