psyke 0.8.2.dev72__py3-none-any.whl → 0.8.4__py3-none-any.whl

psyke/extraction/hypercubic/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 from abc import ABC
 import numpy as np
 import pandas as pd
@@ -96,12 +97,21 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         return prediction, different_prediction_reasons
 
     def __get_local_conditions(self, data: dict[str, float], cube: GenericCube) -> dict[list[Value]]:
-        conditions = {d: [Between(*cube.dimensions[d])] for d in cube.dimensions}
+        conditions = {d: [cube.interval_to_value(d, self.unscale)] for d in data.keys()}
         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 [d for d in c.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]))
+        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]:
+            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]):
+                    try:
+                        conditions[d][-1] *= -condition
+                    except Exception:
+                        conditions[d].append(-condition)
         return conditions
 
     def predict_why(self, data: dict[str, float]):
@@ -112,51 +122,18 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
             output = self._predict_from_cubes(data)
             print(f"The output is {output} because")
             conditions = self.__get_local_conditions(data, cube)
-            for d in data.keys():
-                simplified = HyperCubeExtractor.__simplify(conditions[d])
-                for i, condition in enumerate(simplified):
-                    if i == 0:
+            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=' ')
-                    if isinstance(condition, Outside):
-                        print('not', end=' ')
-                    print('between', round(condition.lower, 1), 'and', round(condition.upper, 1), end=' ')
-                    if i + 1 == len(simplified):
+                    print(condition.print(), end='')
+                    if i + 1 == len(conditions[d]):
                         print()
 
-    @staticmethod
-    def __simplify(conditions):
-        simplified = []
-        for condition in conditions:
-            to_add = True
-            for i, simple in enumerate(simplified):
-                if isinstance(condition, Outside) and isinstance(simple, Outside):
-                    if simple.lower <= condition.lower <= simple.upper or \
-                            simple.lower <= condition.upper <= simple.upper or \
-                            condition.lower <= simple.lower <= simple.upper <= condition.upper:
-                        simplified[i].upper = max(condition.upper, simple.upper)
-                        simplified[i].lower = min(condition.lower, simple.lower)
-                        to_add = False
-                        break
-                elif isinstance(condition, Outside) and isinstance(simple, Between):
-                    if simple.lower >= condition.upper or simple.upper <= condition.lower:
-                        to_add = False
-                        break
-                    elif condition.lower <= simple.lower <= condition.upper <= simple.upper:
-                        simplified[i].lower = condition.upper
-                        to_add = False
-                        break
-                    elif simple.lower <= condition.lower <= simple.upper <= condition.upper:
-                        simplified[i].upper = condition.lower
-                        to_add = False
-                        break
-                    elif condition.lower <= simple.lower <= simple.upper <= condition.upper:
-                        raise ValueError
-            if to_add:
-                simplified.append(condition)
-        return simplified
-
     @staticmethod
     def _create_head(dataframe: pd.DataFrame, variables: list[Var], output: float | LinearRegression) -> Struct:
         return create_head(dataframe.columns[-1], variables[:-1], output) \

psyke/extraction/hypercubic/hypercube.py

@@ -13,7 +13,6 @@ from psyke.utils import get_default_precision, get_int_precision, Target, get_de
 from psyke.utils.logic import create_term, to_rounded_real, linear_function_creator
 from sklearn.linear_model import LinearRegression
 from tuprolog.core import Var, Struct
-from random import Random
 import numpy as np
 
 
@@ -149,6 +148,9 @@ class HyperCube:
         else:
             self._infinite_dimensions[dimension] = [direction]
 
+    def copy_infinite_dimensions(self, dimensions: dict[str, str]):
+        self._infinite_dimensions = dimensions.copy()
+
     @property
     def dimensions(self) -> Dimensions:
         return self._dimensions
@@ -231,12 +233,14 @@ class HyperCube:
         return False
 
     def copy(self) -> HyperCube:
-        return HyperCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube = HyperCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
     def count(self, dataset: pd.DataFrame) -> int:
         return self.filter_dataframe(dataset.iloc[:, :-1]).shape[0]
 
-    def _interval_to_value(self, dimension, unscale):
+    def interval_to_value(self, dimension, unscale=None):
         if dimension not in self._infinite_dimensions:
             return Between(unscale(self[dimension][0], dimension), unscale(self[dimension][1], dimension))
         if len(self._infinite_dimensions[dimension]) == 2:
@@ -247,7 +251,7 @@ class HyperCube:
             return LessThan(unscale(self[dimension][1], dimension))
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
-        values = [(dim, self._interval_to_value(dim, unscale)) for dim in self.dimensions if dim not in ignore]
+        values = [(dim, self.interval_to_value(dim, unscale)) for dim in self.dimensions if dim not in ignore]
         return [create_term(variables[name], value) for name, value in values
                 if not self.is_default and value is not None]
 
@@ -439,8 +443,8 @@ class HyperCube:
 
 
 class RegressionCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output=None):
-        super().__init__(dimension=dimension, output=LinearRegression() if output is None else output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output=None):
+        super().__init__(dimension=dimension, limits=limits, output=LinearRegression() if output is None else output)
 
     def update(self, dataset: pd.DataFrame, predictor) -> None:
         filtered = self.filter_dataframe(dataset.iloc[:, :-1])
@@ -458,7 +462,9 @@ class RegressionCube(HyperCube):
             output.intercept_ = self.output.intercept_
         except AttributeError:
             pass
-        return RegressionCube(self.dimensions.copy(), output=output)
+        new_cube = RegressionCube(self.dimensions.copy(), self._limits.copy(), output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
     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(
@@ -487,12 +493,15 @@ class ClassificationCube(HyperCube):
             self._barycenter = Point(means.index.values, means.values)
 
     def copy(self) -> ClassificationCube:
-        return ClassificationCube(self.dimensions.copy(), self._limits.copy(), self._output)
+        new_cube = ClassificationCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedCube(HyperCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output: str | LinearRegression | float = 0.0):
-        super().__init__(dimension=dimension, output=output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None,
+                 output: str | LinearRegression | float = 0.0):
+        super().__init__(dimension=dimension, limits=limits, output=output)
 
     def __contains__(self, obj: dict[str, float] | ClosedCube) -> bool:
         """
@@ -533,12 +542,14 @@ class ClosedCube(HyperCube):
         return np.all((v[:, 0] <= ds) & (ds <= v[:, 1]), axis=1)
 
     def copy(self) -> ClosedCube:
-        return ClosedCube(self.dimensions.copy(), output=self._output)
+        new_cube = ClosedCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedRegressionCube(ClosedCube, RegressionCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output=None):
-        super().__init__(dimension=dimension, output=LinearRegression() if output is None else output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output=None):
+        super().__init__(dimension=dimension, limits=limits, output=LinearRegression() if output is None else output)
 
     def copy(self) -> ClosedRegressionCube:
         output = LinearRegression()
@@ -547,15 +558,19 @@ class ClosedRegressionCube(ClosedCube, RegressionCube):
             output.intercept_ = self.output.intercept_
         except AttributeError:
             pass
-        return ClosedRegressionCube(self.dimensions.copy(), output=output)
+        new_cube = ClosedRegressionCube(self.dimensions.copy(), self._limits.copy(), output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 class ClosedClassificationCube(ClosedCube, ClassificationCube):
-    def __init__(self, dimension: dict[str, tuple] = None, output: str = None):
-        super().__init__(dimension=dimension, output=output)
+    def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output: str = None):
+        super().__init__(dimension=dimension, limits=limits, output=output)
 
     def copy(self) -> ClosedClassificationCube:
-        return ClosedClassificationCube(self.dimensions.copy(), output=self._output)
+        new_cube = ClosedClassificationCube(self.dimensions.copy(), self._limits.copy(), self.output)
+        new_cube.copy_infinite_dimensions(self._infinite_dimensions)
+        return new_cube
 
 
 GenericCube = Union[HyperCube, ClassificationCube, RegressionCube,

psyke/schema/__init__.py

@@ -85,12 +85,26 @@ class Value:
         else:
             return False
 
+    def __neg__(self) -> Value:
+        if isinstance(self, Constant):
+            return self
+        elif isinstance(self, GreaterThan):
+            return LessThan(self.value, self.standard)
+        elif isinstance(self, LessThan):
+            return GreaterThan(self.value, self.standard)
+        elif isinstance(self, Between):
+            return Outside(self.lower, self.upper, self.standard)
+        elif isinstance(self, Outside):
+            return Between(self.lower, self.upper, self.standard)
+        else:
+            raise TypeError
+
     # TODO: handle convention (low priority).
     def __mul__(self, other) -> Value:
 
         def intersection_with_constant(first_value: Constant, second_value: Value) -> Value:
             if isinstance(first_value, Constant):
-                if second_value.is_in(first_value.value):
+                if first_value in second_value:
                     return first_value
                 else:
                     raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
@@ -100,42 +114,45 @@ class Value:
         def intersection_with_outside(first_value: Outside, second_value: Value) -> Value:
             if isinstance(first_value, Outside):
                 if isinstance(second_value, LessThan):
-                    if second_value.value <= first_value.lower:
-                        return second_value
-                    elif first_value.is_in(second_value.value):
+                    if second_value.value > first_value.upper:
+                        # LessThan(first_value.lower) + Between(first_value.lower, second_value.value)
+                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    elif second_value.value > first_value.lower:
                         return LessThan(first_value.lower)
                     else:
-                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                        return second_value
                 elif isinstance(second_value, GreaterThan):
-                    if second_value.value >= first_value.lower:
+                    if second_value.value < first_value.lower:
+                        # Between(second_value.value, first_value.lower) + GreaterThan(first_value.upper)
+                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    elif second_value.value < first_value.upper:
                         return GreaterThan(first_value.upper)
-                    elif first_value.is_in(second_value.value):
-                        return second_value
                     else:
-                        raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
-                elif isinstance(second_value, Constant):
-                    if not first_value.is_in(second_value.value):
                         return second_value
-                    else:
-                        raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Between):
-                    if second_value in first_value:
+                    if second_value.upper <= first_value.lower or second_value.lower >= first_value.upper:
                         return second_value
                     elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
                         return Between(second_value.lower, first_value.lower)
                     elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
                         return Between(first_value.upper, second_value.upper)
-                    else:
+                    elif second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
                         raise _NOT_IMPLEMENTED_INTERSECTION(first_value, second_value)
+                    else:
+                        raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Outside):
-                    if second_value.lower <= first_value.lower and second_value.upper >= first_value.upper:
+                    if second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
                         return second_value
-                    elif first_value.lower <= second_value.lower and first_value.upper >= second_value.upper:
+                    elif first_value.lower <= second_value.lower <= second_value.upper <= first_value.upper:
                         return first_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(second_value.lower, first_value.upper)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(first_value.lower, second_value.upper)
                     else:
                         raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Constant):
-                    intersection_with_constant(second_value, first_value)
+                    return intersection_with_constant(second_value, first_value)
                 else:
                     raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
             else:
@@ -173,7 +190,7 @@ class Value:
                     else:
                         raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
                 elif isinstance(second_value, Constant):
-                    intersection_with_constant(second_value, first_value)
+                    return intersection_with_constant(second_value, first_value)
                 elif isinstance(second_value, Outside):
                     return intersection_with_outside(second_value, first_value)
                 else:
@@ -264,6 +281,9 @@ class LessThan(Interval):
     def value(self) -> float:
         return self.upper
 
+    def print(self) -> str:
+        return f"below {round(self.upper, 1)}"
+
     def __str__(self):
         return f"]-∞, {self.upper:.2f}" + ("]" if self.standard else "[")
 
@@ -286,6 +306,9 @@ class GreaterThan(Interval):
     def value(self) -> float:
         return self.lower
 
+    def print(self) -> str:
+        return f"above {round(self.lower, 1)}"
+
     def __str__(self):
         return ("]" if self.standard else "[") + f"{self.lower:.2f}, ∞["
 
@@ -304,6 +327,9 @@ class Between(Interval):
     def is_in(self, other: float) -> bool:
         return self.lower <= other < self.upper if self.standard else self.lower < other <= self.upper
 
+    def print(self) -> str:
+        return f"between {round(self.lower, 1)} and {round(self.upper, 1)}"
+
     def __str__(self):
         return ("[" if self.standard else "]") + f"{self.lower:.2f}, {self.upper:.2f}" + ("[" if self.standard else "]")
 
@@ -319,6 +345,9 @@ class Outside(Interval):
     def is_in(self, other: float) -> bool:
         return other < self.lower or self.upper <= other if self.standard else other <= self.lower or self.upper < other
 
+    def print(self) -> str:
+        return f"not between {round(self.lower, 1)} and {round(self.upper, 1)}"
+
     def __str__(self):
         return f"]-∞, {self.lower:.2f}" + ("[" if self.standard else "]") + ' U '\
                + ("[" if self.standard else "]") + f"{self.upper:.2f}, ∞["
@@ -336,6 +365,9 @@ class Constant(Value):
     def is_in(self, other: float) -> bool:
         return math.isclose(other, self.value)
 
+    def print(self) -> str:
+        return f"equal {round(self.value, 1)}"
+
     def __str__(self):
         return "{" + str(self.value) + "}"
 

{psyke-0.8.2.dev72.dist-info → psyke-0.8.4.dist-info}/METADATA

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

@@ -7,8 +7,8 @@ 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=34ZB7zwLs3NKaJBKlpxytnyfGtOl9LVdZX3ppxZrN8k,12042
-psyke/extraction/hypercubic/hypercube.py,sha256=Ws0tky0CMvCVuIwBJNxmY97xsG7VapwLQ2uSwpWlb1g,24510
+psyke/extraction/hypercubic/__init__.py,sha256=vV4xIvyUyeQczrTHYuBzHcQrNc_967x7ZWHT3FommUg,10599
+psyke/extraction/hypercubic/hypercube.py,sha256=kDEhYlY7EahWV07AwEZIdEu94HIQUw-CdoKBdle61BQ,25430
 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
@@ -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=gOUWx3gYSkRehlJ5opK0Q16-Tv5fwSTl19k7kzIHALU,15760
+psyke/schema/__init__.py,sha256=R3rH22YdA_aEB62YBJXGHpcVAgxZ12jFzgQFzKTzfDc,17306
 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.2.dev72.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
-psyke-0.8.2.dev72.dist-info/METADATA,sha256=oNgGeNL3rG3VvOlf-yDu8rVus9SmVZBiI1s_I3ZD8hg,8108
-psyke-0.8.2.dev72.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-psyke-0.8.2.dev72.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
-psyke-0.8.2.dev72.dist-info/RECORD,,
+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,,