psyke 0.8.2.dev1__tar.gz → 0.8.2.dev4__tar.gz

{psyke-0.8.2.dev1/psyke.egg-info → psyke-0.8.2.dev4}/PKG-INFO

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

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

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4}/psyke/extraction/hypercubic/__init__.py

@@ -40,16 +40,6 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         cubes.sort()
         self._hypercubes = [cube[2] for cube in cubes]
 
-    def _last_cube_as_default(self, theory):
-        last_clause = list(theory.clauses)[-1]
-        theory.retract(last_clause)
-        theory.assertZ(clause(
-            last_clause.head, [last_in_body(last_clause.body)] if self._output is Target.REGRESSION else []))
-        last_cube = self._hypercubes[-1]
-        for dimension in last_cube.dimensions.keys():
-            last_cube[dimension] = [-np.inf, np.inf]
-        return theory
-
     def extract(self, dataframe: pd.DataFrame) -> Theory:
         theory = PedagogicalExtractor.extract(self, dataframe)
         self._surrounding = HyperCube.create_surrounding_cube(dataframe, output=self._output)
@@ -57,7 +47,7 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         return theory
 
     def predict_counter(self, data: dict[str, float]):
-        cube = self._find_cube(data)
+        cube = self._find_cube(data.copy())
         if cube is None:
             print("The extracted knowledge is not exhaustive; impossible to predict this instance")
         else:
@@ -72,7 +62,7 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
                 outputs.append(c.output)
                 print("The output may be", c.output, 'if')
 
-                for d in c.dimensions.keys():
+                for d in point.dimensions.keys():
                     lower, upper = c[d]
                     p = point[d]
                     if p < lower:
@@ -91,14 +81,14 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         return conditions
 
     def predict_why(self, data: dict[str, float]):
-        cube = self._find_cube(data)
+        cube = self._find_cube(data.copy())
         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(cube)
-            for d in conditions:
+            for d in data.keys():
                 simplified = HyperCubeExtractor.__simplify(conditions[d])
                 for i, condition in enumerate(simplified):
                     if i == 0:
@@ -149,14 +139,14 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
             if not isinstance(output, LinearRegression) else \
             create_head(dataframe.columns[-1], variables[:-1], variables[-1])
 
-    def _ignore_dimensions(self, cube: HyperCube) -> Iterable[str]:
-        return [d for d in cube.dimensions if cube[d][0] == -np.inf or cube[d][1] == np.inf]
-
     def __drop(self, dataframe: pd.DataFrame):
         self._hypercubes = [cube for cube in self._hypercubes if cube.count(dataframe) > 1]
 
     def _create_theory(self, dataframe: pd.DataFrame) -> Theory:
         self.__drop(dataframe)
+        if self._default_surrounding_cube:
+            self._hypercubes[-1].set_default()
+
         new_theory = mutable_theory()
         for cube in self._hypercubes:
             logger.info(cube.output)
@@ -165,10 +155,9 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
             variables[dataframe.columns[-1]] = to_var(dataframe.columns[-1])
             head = HyperCubeExtractor._create_head(dataframe, list(variables.values()),
                                                    self.unscale(cube.output, dataframe.columns[-1]))
-            body = cube.body(variables, self._ignore_dimensions(cube), self.unscale, self.normalization)
+            body = cube.body(variables, self._dimensions_to_ignore, self.unscale, self.normalization)
             new_theory.assertZ(clause(head, body))
-        new_theory = HyperCubeExtractor._prettify_theory(new_theory)
-        return self._last_cube_as_default(new_theory) if self._default_surrounding_cube else new_theory
+        return HyperCubeExtractor._prettify_theory(new_theory)
 
     @staticmethod
     def _prettify_theory(theory: Theory) -> Theory:

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4}/psyke/extraction/hypercubic/creepy/__init__.py

@@ -24,9 +24,8 @@ class CReEPy(HyperCubeExtractor):
                          discretization, normalization)
         self.clustering = clustering(depth, error_threshold, self._output, gauss_components, discretization,
                                      normalization, seed)
-        self.ranks = ranks
-        self.ignore_threshold = ignore_threshold
         self._default_surrounding_cube = True
+        self._dimensions_to_ignore = [dimension for dimension, relevance in ranks if relevance < ignore_threshold]
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
         if not isinstance(self.clustering, HyperCubeClustering):
@@ -34,8 +33,4 @@ class CReEPy(HyperCubeExtractor):
 
         self.clustering.fit(dataframe)
         self._hypercubes = self.clustering.get_hypercubes()
-        for cube in self._hypercubes:
-            for dimension, relevance in self.ranks:
-                if relevance < self.ignore_threshold:
-                    cube[dimension] = [-np.inf, np.inf]
         return self._create_theory(dataframe)

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4}/psyke/extraction/hypercubic/gridex/__init__.py

@@ -37,7 +37,8 @@ class GridEx(HyperCubeExtractor):
         for (feature, (a, b)) in cube.dimensions.items():
             n_bins = self.grid.get(feature, iteration)
             if n_bins == 1:
-                ranges[feature] = [(-np.inf, np.inf)]
+                ranges[feature] = [(a, b)]
+                self._dimensions_to_ignore.append(feature)
             else:
                 size = (b - a) / n_bins
                 ranges[feature] = [(a + size * i, a + size * (i + 1)) for i in range(n_bins)]

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4}/psyke/extraction/hypercubic/hypercube.py

@@ -82,6 +82,7 @@ class HyperCube:
         self._diversity = 0.0
         self._error = 0.0
         self._barycenter = Point([], [])
+        self._default = False
 
     def __contains__(self, obj: dict[str, float] | HyperCube) -> bool:
         """
@@ -116,6 +117,13 @@ class HyperCube:
         result = [hash(name + str(dimension[0]) + str(dimension[1])) for name, dimension in self.dimensions.items()]
         return sum(result)
 
+    @property
+    def is_default(self) -> bool:
+        return self._default
+
+    def set_default(self):
+        self._default = True
+
     @property
     def dimensions(self) -> Dimensions:
         return self._dimensions
@@ -212,12 +220,8 @@ class HyperCube:
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
         dimensions = dict(self.dimensions)
-        # TODO: there is something strange in the tests here
-        # print('search', [name for name in dimensions.keys()], 'in', (variables.keys()))
-        for dimension in ignore:
-            del dimensions[dimension]
         return [create_term(variables[name], Between(unscale(values[0], name), unscale(values[1], name)))
-                for name, values in dimensions.items()]
+                for name, values in dimensions.items() if name not in ignore and not self.is_default]
 
     @staticmethod
     def create_surrounding_cube(dataset: pd.DataFrame, closed: bool = False,
@@ -282,10 +286,12 @@ class HyperCube:
         return self[feature][1]
 
     def has_volume(self) -> bool:
-        return all([dimension[1] - dimension[0] > HyperCube.EPSILON for dimension in self._dimensions.values()])
+        return all([dimension[1] - dimension[0] > HyperCube.EPSILON for dimension in self._dimensions.values()
+                    if np.isfinite(dimension[0]) and np.isfinite(dimension[1])])
 
     def volume(self) -> float:
-        return reduce(lambda a, b: a * b, [dimension[1] - dimension[0] for dimension in self._dimensions.values()], 1)
+        return reduce(lambda a, b: a * b, [dimension[1] - dimension[0] for dimension in self._dimensions.values()
+                                           if np.isfinite(dimension[0]) and np.isfinite(dimension[1])], 1)
 
     def diagonal(self) -> float:
         return reduce(
@@ -304,7 +310,7 @@ class HyperCube:
 
     def surface_distance(self, point: Point) -> float:
         s = 0
-        for d in self.dimensions.keys():
+        for d in point.dimensions.keys():
             lower, upper = self[d]
             p = point[d]
             if p > upper:
@@ -409,8 +415,8 @@ class HyperCube:
 
 
 class RegressionCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None):
-        super().__init__(dimension=dimension, output=LinearRegression())
+    def __init__(self, dimension: dict[str, tuple] = None, output=LinearRegression()):
+        super().__init__(dimension=dimension, output=output)
 
     def update(self, dataset: pd.DataFrame, predictor) -> None:
         filtered = self.filter_dataframe(dataset.iloc[:, :-1])
@@ -422,7 +428,7 @@ class RegressionCube(HyperCube):
             self._barycenter = Point(means.index.values, means.values)
 
     def copy(self) -> RegressionCube:
-        return RegressionCube(self.dimensions.copy())
+        return RegressionCube(self.dimensions.copy(), output=self._output)
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
         intercept = self.output.intercept_ if normalization is None else unscale(sum(
@@ -455,8 +461,8 @@ class ClassificationCube(HyperCube):
 
 
 class ClosedCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None):
-        super().__init__(dimension=dimension)
+    def __init__(self, dimension: dict[str, tuple] = None, output: str | LinearRegression | float = 0.0):
+        super().__init__(dimension=dimension, output=output)
 
     def __contains__(self, obj: dict[str, float] | ClosedCube) -> bool:
         """
@@ -479,23 +485,23 @@ class ClosedCube(HyperCube):
         return np.all((v[:, 0] <= ds) & (ds <= v[:, 1]), axis=1)
 
     def copy(self) -> ClosedCube:
-        return ClosedCube(self.dimensions.copy())
+        return ClosedCube(self.dimensions.copy(), output=self._output)
 
 
 class ClosedRegressionCube(ClosedCube, RegressionCube):
-    def __init__(self, dimension: dict[str, tuple] = None):
-        super().__init__(dimension=dimension)
+    def __init__(self, dimension: dict[str, tuple] = None, output: LinearRegression = LinearRegression()):
+        super().__init__(dimension=dimension, output=output)
 
     def copy(self) -> ClosedRegressionCube:
-        return ClosedRegressionCube(self.dimensions.copy())
+        return ClosedRegressionCube(self.dimensions.copy(), output=self._output)
 
 
 class ClosedClassificationCube(ClosedCube, ClassificationCube):
-    def __init__(self, dimension: dict[str, tuple] = None):
-        super().__init__(dimension=dimension)
+    def __init__(self, dimension: dict[str, tuple] = None, output: str = None):
+        super().__init__(dimension=dimension, output=output)
 
     def copy(self) -> ClosedClassificationCube:
-        return ClosedClassificationCube(self.dimensions.copy())
+        return ClosedClassificationCube(self.dimensions.copy(), output=self._output)
 
 
 GenericCube = Union[HyperCube, ClassificationCube, RegressionCube,

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4}/psyke/hypercubepredictor.py

@@ -14,6 +14,7 @@ class HyperCubePredictor(EvaluableModel):
     def __init__(self, output=Target.CONSTANT, discretization=None, normalization=None):
         super().__init__(discretization, normalization)
         self._hypercubes = []
+        self._dimensions_to_ignore = []
         self._output = output
         self._surrounding = None
 
@@ -75,10 +76,16 @@ class HyperCubePredictor(EvaluableModel):
             return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
 
     def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        for dimension in self._dimensions_to_ignore:
+            del data[dimension]
+        found = None
         for cube in self._hypercubes:
             if data in cube:
-                return cube
-        return None
+                found = cube.copy()
+                break
+        if found is None and self._hypercubes[-1].is_default:
+            found = self._hypercubes[-1].copy()
+        return found
 
     @property
     def n_rules(self):

{psyke-0.8.2.dev1 → psyke-0.8.2.dev4/psyke.egg-info}/PKG-INFO

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

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