psyke 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

psyke/__init__.py

@@ -61,7 +61,7 @@ class EvaluableModel(object):
         raise NotImplementedError('predict')
 
     def __convert(self, ys: Iterable) -> Iterable:
-        if self.normalization is not None:
+        if self.normalization is not None and not isinstance([p for p in ys if p is not None][0], str):
             m, s = self.normalization[list(self.normalization.keys())[-1]]
             ys = [prediction if prediction is None else prediction * s + m for prediction in ys]
         return ys
@@ -73,7 +73,7 @@ class EvaluableModel(object):
         raise NotImplementedError('brute_predict')
 
     def unscale(self, values, name):
-        if self.normalization is None or isinstance(values, LinearRegression):
+        if self.normalization is None or name not in self.normalization or isinstance(values, LinearRegression):
             return values
         if isinstance(values, Iterable):
             values = [None if value is None else
@@ -161,17 +161,20 @@ class Extractor(EvaluableModel, ABC):
         """
         raise NotImplementedError('extract')
 
-    def predict_why(self, data: dict[str, float]):
+    def predict_why(self, data: dict[str, float], verbose=True):
         """
         Provides a prediction and the corresponding explanation.
         :param data: is the instance to predict.
+        :param verbose: if the explanation has to be printed.
         """
         raise NotImplementedError('predict_why')
 
-    def predict_counter(self, data: dict[str, float]):
+    def predict_counter(self, data: dict[str, float], verbose=True, only_first=True):
         """
         Provides a prediction and counterfactual explanations.
         :param data: is the instance to predict.
+        :param verbose: if the counterfactual explanation has to be printed.
+        :param only_first: if only the closest counterfactual explanation is provided for each distinct class.
         """
         raise NotImplementedError('predict_counter')
 

psyke/extraction/hypercubic/__init__.py

@@ -44,8 +44,8 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         return theory
 
     def pairwise_fairness(self, data: dict[str, float], neighbor: dict[str, float]):
-        cube1 = self._find_cube(data.copy())
-        cube2 = self._find_cube(neighbor.copy())
+        cube1 = self._find_cube(data)
+        cube2 = self._find_cube(neighbor)
         different_prediction_reasons = []
 
         if cube1.output == cube2.output:
@@ -63,76 +63,83 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
                     different_prediction_reasons.append(d)
         return different_prediction_reasons
 
-    def predict_counter(self, data: dict[str, float], verbose=True):
+    def predict_counter(self, data: dict[str, float], verbose=True, only_first=True):
         output = ""
         prediction = None
-        cube = self._find_cube(data.copy())
+        cube = self._find_cube(data)
         if cube is None:
             output += "The extracted knowledge is not exhaustive; impossible to predict this instance"
         else:
             prediction = self._predict_from_cubes(data)
-            output += f"The output is {prediction}"
+            output += f"The output is {prediction}\n"
 
         point = Point(list(data.keys()), list(data.values()))
         cubes = self._hypercubes if cube is None else [c for c in self._hypercubes if cube.output != c.output]
         cubes = sorted([(cube.surface_distance(point), cube.volume(), i, cube) for i, cube in enumerate(cubes)])
-        outputs = []
-        different_prediction_reasons = []
+
+        counter_conditions = []
+
         for _, _, _, c in cubes:
-            if c.output not in outputs:
-                outputs.append(c.output)
-                output += f"\nThe output may be {c.output} if"
-
-                for d in point.dimensions.keys():
-                    lower, upper = c[d]
-                    p = point[d]
-                    if p < lower:
-                        output += f"\n     {d} increases above {round(lower, 1)}"
-                        different_prediction_reasons.append((d, '>=', lower))
-                    elif p > upper:
-                        output += f"\n     {d} decreses below {round(upper, 1)}"
-                        different_prediction_reasons.append((d, '<=', upper))
+            if not only_first or c.output not in [o for o, _ in counter_conditions]:
+                counter_conditions.append((c.output, {c: [val for val in v if val is not None and not val.is_in(
+                    self.unscale(data[c], c))] for c, v in self.__get_conditions(data, c).items()}))
+
         if verbose:
+            for o, conditions in counter_conditions:
+                output += f"The output may be {o} if\n" + HyperCubeExtractor.__conditions_to_string(conditions)
             print(output)
-        return prediction, different_prediction_reasons
 
-    def __get_local_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[list[Value]]:
-        conditions = {d: [cube.interval_to_value(d, self.unscale)] for d in data.keys()}
-        subcubes = cube.subcubes(self._hypercubes)
-        subsubcubes = [c for cube_list in [c.subcubes(self._hypercubes) for c in subcubes] for c in cube_list]
-        for c in [c for c in subcubes if c not in subsubcubes]:
+        return prediction, counter_conditions
+
+    @staticmethod
+    def __conditions_to_string(conditions: dict[str, list[Value]]) -> str:
+        output = ""
+        for d in conditions:
+            for i, condition in enumerate(conditions[d]):
+                if i == 0:
+                    output += f'     {d} is '
+                else:
+                    output += ' and '
+                output += condition.print()
+                if i + 1 == len(conditions[d]):
+                    output += '\n'
+        return output
+
+    def __get_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[str, list[Value]]:
+        conditions = {d: [cube.interval_to_value(d, self.unscale)] for d in data.keys()
+                      if d not in self._dimensions_to_ignore}
+        for c in cube.subcubes(self._hypercubes):
             for d in conditions:
                 condition = c.interval_to_value(d, self.unscale)
                 if condition is None:
                     continue
                 elif conditions[d][-1] is None:
                     conditions[d][-1] = -condition
-                elif (-condition).is_in(data[d]):
+                else:
                     try:
                         conditions[d][-1] *= -condition
                     except Exception:
                         conditions[d].append(-condition)
         return conditions
 
-    def predict_why(self, data: dict[str, float]):
-        cube = self._find_cube(data.copy())
+    def predict_why(self, data: dict[str, float], verbose=True):
+        cube = self._find_cube(data)
+        output = ""
         if cube is None:
-            print("The extracted knowledge is not exhaustive; impossible to predict this instance")
-        else:
-            output = self._predict_from_cubes(data)
-            print(f"The output is {output} because")
-            conditions = self.__get_local_conditions(data, cube)
-            for d in conditions:
-                for i, condition in enumerate(conditions[d]):
-                    if condition is None:
-                        continue
-                    elif i == 0:
-                        print('    ', d, 'is', end=' ')
-                    else:
-                        print('and', end=' ')
-                    print(condition.print(), end='')
-                    if i + 1 == len(conditions[d]):
-                        print()
+            output += "The extracted knowledge is not exhaustive; impossible to predict this instance\n"
+            if verbose:
+                print(output)
+            return None, {}
+        prediction = self._predict_from_cubes(data)
+        output += f"The output is {prediction} because\n"
+        conditions = {c: [val for val in v if val is not None and val.is_in(self.unscale(data[c], c))]
+                      for c, v in self.__get_conditions(data, cube).items()}
+
+        if verbose:
+            output += HyperCubeExtractor.__conditions_to_string(conditions)
+            print(output)
+
+        return prediction, conditions
 
     @staticmethod
     def _create_head(dataframe: pd.DataFrame, variables: list[Var], output: float | LinearRegression) -> Struct:

psyke/extraction/hypercubic/creepy/__init__.py

@@ -25,7 +25,7 @@ class CReEPy(HyperCubeExtractor):
         self.clustering = clustering(depth, error_threshold, self._output, gauss_components, discretization,
                                      normalization, seed)
         self._default_surrounding_cube = True
-        self._dimensions_to_ignore = [dimension for dimension, relevance in ranks if relevance < ignore_threshold]
+        self._dimensions_to_ignore = set([dimension for dimension, relevance in ranks if relevance < ignore_threshold])
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
         if not isinstance(self.clustering, HyperCubeClustering):

psyke/extraction/hypercubic/hypercube.py

@@ -175,8 +175,12 @@ class HyperCube:
     def barycenter(self) -> Point:
         return self._barycenter
 
-    def subcubes(self, cubes: Iterable[GenericCube]) -> Iterable[GenericCube]:
-        return [c for c in cubes if c in self and c != self]
+    def subcubes(self, cubes: Iterable[GenericCube], only_largest: bool = True) -> Iterable[GenericCube]:
+        subcubes = [c for c in cubes if c in self and c.output != self.output]
+        if only_largest:
+            subsubcubes = [c for cube_list in [c.subcubes(cubes) for c in subcubes] for c in cube_list]
+            subcubes = [c for c in subcubes if c not in subsubcubes]
+        return subcubes
 
     def _fit_dimension(self, dimension: dict[str, tuple[float, float]]) -> dict[str, tuple[float, float]]:
         new_dimension: dict[str, tuple[float, float]] = {}

psyke/hypercubepredictor.py

@@ -76,8 +76,10 @@ class HyperCubePredictor(EvaluableModel):
             return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
 
     def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        data = data.copy()
         for dimension in self._dimensions_to_ignore:
-            del data[dimension]
+            if dimension in data:
+                del data[dimension]
         for cube in self._hypercubes:
             if data in cube:
                 return cube.copy()

psyke/schema/__init__.py

@@ -4,7 +4,7 @@ from typing import Callable
 from psyke.utils import get_int_precision
 
 _EMPTY_INTERSECTION_EXCEPTION: Callable = lambda x, y: \
-    Exception("Empty intersection between two Value: " + str(x) + ' and ' + str(y))
+    Exception(f"Empty intersection between two Value: {str(x)} and {str(y)}")
 
 _NOT_IMPLEMENTED_INTERSECTION: Callable = lambda x, y: \
     Exception("Not implemented intersection between: " + str(x) + ' and ' + str(y))
@@ -250,6 +250,9 @@ class Value:
         else:
             raise _INTERSECTION_WITH_WRONG_TYPE(self, other)
 
+    def print(self) -> str:
+        pass
+
 
 class Interval(Value):
 
@@ -265,7 +268,7 @@ class Interval(Value):
     def __repr__(self):
         return f"Interval({self.lower:.2f}, {self.upper:.2f})"
 
-    def __eq__(self, other: Between) -> bool:
+    def __eq__(self, other: Interval) -> bool:
         return (self.upper == other.upper) and (self.lower == other.lower) and (self.standard == other.standard)
 
 
@@ -291,7 +294,8 @@ class LessThan(Interval):
         return f"LessThan({self.upper:.2f})"
 
     def __eq__(self, other: LessThan) -> bool:
-        return (self.upper == other.upper) and (self.value == other.value) and (self.standard == other.standard)
+        return isinstance(other, LessThan) and (self.upper == other.upper) and \
+               (self.value == other.value) and (self.standard == other.standard)
 
 
 class GreaterThan(Interval):
@@ -316,7 +320,8 @@ class GreaterThan(Interval):
         return f"GreaterThan({self.lower:.2f})"
 
     def __eq__(self, other: GreaterThan) -> bool:
-        return (self.lower == other.lower) and (self.value == other.value) and (self.standard == other.standard)
+        return isinstance(other, GreaterThan) and (self.lower == other.lower) and \
+               (self.value == other.value) and (self.standard == other.standard)
 
 
 class Between(Interval):

{psyke-0.8.4.dist-info → psyke-0.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.4
+Version: 0.8.5
 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.8.4.dist-info → psyke-0.8.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
-psyke/__init__.py,sha256=weEnLws23jzCu_wqZVfq-jVlikiGle14coSMrjUnt7w,18155
-psyke/hypercubepredictor.py,sha256=XceZtTy70QI0PaoCuowvnJWZWcF3NoWF4Khd3qXHCgk,4507
+psyke/__init__.py,sha256=MSMiwvVth4kqmGvQt6HiYNR3J4EdINe8PBmK8-DQVSo,18545
+psyke/hypercubepredictor.py,sha256=MlSRLky6J1I07qKcH98c9WvEjFHGyBiz_LU9W_oDnqs,4572
 psyke/clustering/__init__.py,sha256=36MokTVwwWR_-o0mesvXHaYEYVTK2pn2m0ZY4G3Y3qU,581
 psyke/clustering/utils.py,sha256=S0YwCKyHVYp9qUAQVzCMrTwcQFPJ5TD14Jwn10DE-Z4,1616
 psyke/clustering/cream/__init__.py,sha256=W6k7vdjuUdA_azYA4vb5JtpWrofhDJ0DbM2jsnRKzfw,2994
@@ -7,12 +7,12 @@ psyke/clustering/exact/__init__.py,sha256=s4MPvGZ6gle3X9WH3YFHOEdinGcXIXh-7EFRcE
 psyke/extraction/__init__.py,sha256=ziZ8T9eAOZjKipepE5_j1zfZgyFPONjW8MGERSk83nI,743
 psyke/extraction/cart/__init__.py,sha256=s8tr7jPhONgF0pfetHieFax2MD8cy6ddOS7dRWzZLjc,3579
 psyke/extraction/cart/predictor.py,sha256=2-2mv5fI0lTwwfTaEonxKh0ZUdhxuIEE6OP_rJxgmqc,3019
-psyke/extraction/hypercubic/__init__.py,sha256=vV4xIvyUyeQczrTHYuBzHcQrNc_967x7ZWHT3FommUg,10599
-psyke/extraction/hypercubic/hypercube.py,sha256=kDEhYlY7EahWV07AwEZIdEu94HIQUw-CdoKBdle61BQ,25430
+psyke/extraction/hypercubic/__init__.py,sha256=w_NmfSjh8fCWLDXVXpRLiAApq697cvUSPTgju-jtZCA,10620
+psyke/extraction/hypercubic/hypercube.py,sha256=GKjplRl34BegrA3JclvlkrL7hXftdUUMXndmRFFoJic,25697
 psyke/extraction/hypercubic/strategy.py,sha256=X-roIsfcpJyMdo2px5JtbhP7-XE-zUNkaEK7XGXoWA8,1636
 psyke/extraction/hypercubic/utils.py,sha256=D2FN5CCm_T3h23DmLFoTnIcFo7LvIq__ktl4hjUqkcA,1525
 psyke/extraction/hypercubic/cosmik/__init__.py,sha256=XQUvOtMFpR0vMHYtwIVl3G626HMqN8Clt6BqNm4nvFs,1880
-psyke/extraction/hypercubic/creepy/__init__.py,sha256=8bT0zVsJs9odlVuMIzQUzMwUpfcFwbULzm7dlbhyJkg,1730
+psyke/extraction/hypercubic/creepy/__init__.py,sha256=js91nWXOSJtRFFjnNzv4eDKnRYthe1GA1a-CGAaHzDM,1735
 psyke/extraction/hypercubic/divine/__init__.py,sha256=ClO8CITKKXoo7nhlBJagR1yAachsxLHYQlqggl-9eGE,3665
 psyke/extraction/hypercubic/gridex/__init__.py,sha256=o7tNU3JH8AqA2PRj839-rPb6zhwAdpaCVGC__0DH-b0,5543
 psyke/extraction/hypercubic/gridrex/__init__.py,sha256=h9usK5tFqd6ngBmRydsgkfQ1jlcQKj2uG72Tr1puFHk,595
@@ -22,7 +22,7 @@ psyke/extraction/real/__init__.py,sha256=fFqiwgWTpu5Jx9lz5CdSfs1QyqWYFLQDG7tc5M6
 psyke/extraction/real/utils.py,sha256=eHGU-Y0inn_8jrk9lMcuRUKXpsTkI-s_myXSWz4bALQ,2190
 psyke/extraction/trepan/__init__.py,sha256=KpZpk0btCWV4bS-DOmpgpYscSQ5FEMyP54ekm7ZedME,6583
 psyke/extraction/trepan/utils.py,sha256=iSUJ1ooNQT_VO1KfBZuIUeUsyUbGdQf_pSEE87vMeQg,2320
-psyke/schema/__init__.py,sha256=R3rH22YdA_aEB62YBJXGHpcVAgxZ12jFzgQFzKTzfDc,17306
+psyke/schema/__init__.py,sha256=66Jm4hk9s2ZBdXUF7tg43_zG0X6XicMYOPsBkXyY0wE,17444
 psyke/tuning/__init__.py,sha256=I-07lLZb02DoIm9AGXPPPOkB55ANu8RU4TMy2j30Pxg,3574
 psyke/tuning/crash/__init__.py,sha256=zIHEF75EFy_mRIieqzP04qKLG3GLsSc_mYZHpPfkzxU,2623
 psyke/tuning/orchid/__init__.py,sha256=s64iABbteik27CrRPHSVHNZX25JKlDu7YYjhseOizxw,3618
@@ -33,8 +33,8 @@ psyke/utils/logic.py,sha256=7bbW6qcKof5PlqoQ0n5Kt3Obcot-KqGAvpE8rMXvEPE,12419
 psyke/utils/metrics.py,sha256=Oo5BOonOSfo0qYsXWT5dmypZ7jiStByFC2MKEU0uMHg,2250
 psyke/utils/plot.py,sha256=dE8JJ6tQ0Ezosid-r2jqAisREjFe5LqExRzsVi5Ns-c,7785
 psyke/utils/sorted.py,sha256=C3CPW2JisND30BRk5c1sAAHs3Lb_wsRB2qZrYFuRnfM,678
-psyke-0.8.4.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
-psyke-0.8.4.dist-info/METADATA,sha256=EVJVC6zctQogYTfCiBn1qkTar-2J7X7YiSfHom0TK0U,8102
-psyke-0.8.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-psyke-0.8.4.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
-psyke-0.8.4.dist-info/RECORD,,
+psyke-0.8.5.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
+psyke-0.8.5.dist-info/METADATA,sha256=5BPTGj6knIWcdwIdQZaXQTPAsl4CLMADsXHZNU9J10w,8102
+psyke-0.8.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+psyke-0.8.5.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
+psyke-0.8.5.dist-info/RECORD,,