psyke 0.8.2.dev9__tar.gz → 0.8.2.dev12__tar.gz

{psyke-0.8.2.dev9/psyke.egg-info → psyke-0.8.2.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.2.dev9
+Version: 0.8.2.dev12
 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.2.dev12/VERSION

@@ -0,0 +1 @@
+0.8.2.dev12

{psyke-0.8.2.dev9 → psyke-0.8.2.dev12}/psyke/extraction/hypercubic/__init__.py

@@ -44,38 +44,68 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         self._surrounding.update(dataframe, self.predictor)
         return theory
 
-    def predict_counter(self, data: dict[str, float]):
+    def pairwise_fairness(self, data: dict[str, float], neighbor: dict[str, float]):
+        cube1 = self._find_cube(data.copy())
+        cube2 = self._find_cube(neighbor.copy())
+        different_prediction_reasons = []
+
+        if cube1.output == cube2.output:
+            print("Prediction", cube1.output, "is FAIR")
+        else:
+            print("Prediction", cube1.output, "may be UNFAIR")
+            print("It could be", cube2.output, "if:")
+            for d in data:
+                a, b = cube2.dimensions[d]
+                if data[d] < a:
+                    print('    ', d, 'increases above', round(a, 1))
+                    different_prediction_reasons.append(d)
+                elif data[d] > b:
+                    print('    ', d, 'decreases below', round(b, 1))
+                    different_prediction_reasons.append(d)
+        return different_prediction_reasons
+
+    def predict_counter(self, data: dict[str, float], verbose=True):
+        output = ""
+        prediction = None
         cube = self._find_cube(data.copy())
         if cube is None:
-            print("The extracted knowledge is not exhaustive; impossible to predict this instance")
+            output += "The extracted knowledge is not exhaustive; impossible to predict this instance"
         else:
-            print("The output is", self._predict_from_cubes(data))
+            prediction = self._predict_from_cubes(data)
+            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(), cube) for cube in cubes])
         outputs = []
+        different_prediction_reasons = []
         for _, _, c in cubes:
             if c.output not in outputs:
                 outputs.append(c.output)
-                print("The output may be", c.output, 'if')
+                output += f"The output may be {c.output} if"
 
                 for d in point.dimensions.keys():
                     lower, upper = c[d]
                     p = point[d]
                     if p < lower:
-                        print('    ', d, '=', round(lower, 1))
+                        output += f"\n     {d} increases above {round(lower, 1)}"
+                        different_prediction_reasons.append((d, '>=', lower))
                     elif p > upper:
-                        print('    ', d, '=', round(upper, 1))
+                        output += f"\n     {d} decreses below {round(upper, 1)}"
+                        different_prediction_reasons.append((d, '<=', upper))
+        if verbose:
+            print(output)
+        return prediction, different_prediction_reasons
 
-    def __get_local_conditions(self, cube: GenericCube) -> dict[list[Value]]:
+    def __get_local_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[list[Value]]:
         conditions = {d: [] for d in cube.dimensions}
         for d in cube.finite_dimensions:
             conditions[d].append(Between(*cube.dimensions[d]))
         subcubes = cube.subcubes(self._hypercubes)
         for c in [c for c in subcubes if sum(c in sc and c != sc for sc in subcubes) == 0]:
-            for d in c.finite_dimensions:
-                conditions[d].append(Outside(*c.dimensions[d]))
+            for d in [d for d in c.finite_dimensions if d in data]:
+                if c.dimensions[d][0] > data[d] or c.dimensions[d][1] < data[d]:
+                    conditions[d].append(Outside(*c.dimensions[d]))
         return conditions
 
     def predict_why(self, data: dict[str, float]):
@@ -85,7 +115,7 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         else:
             output = self._predict_from_cubes(data)
             print(f"The output is {output} because")
-            conditions = self.__get_local_conditions(cube)
+            conditions = self.__get_local_conditions(data, cube)
             for d in data.keys():
                 simplified = HyperCubeExtractor.__simplify(conditions[d])
                 for i, condition in enumerate(simplified):

{psyke-0.8.2.dev9 → psyke-0.8.2.dev12/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.2.dev9
+Version: 0.8.2.dev12
 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.2.dev9/VERSION

@@ -1 +0,0 @@
-0.8.2.dev9