psyke 0.8.6.dev2__tar.gz → 0.8.9__tar.gz

{psyke-0.8.6.dev2/psyke.egg-info → psyke-0.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.6.dev2
+Version: 0.8.9
 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.9/VERSION

@@ -0,0 +1 @@
+0.8.9

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/__init__.py

@@ -256,14 +256,14 @@ class Extractor(EvaluableModel, ABC):
                           [Extractor.ClassificationScore.F1])[Extractor.ClassificationScore.F1][-1]
 
     @staticmethod
-    def cart(predictor, max_depth: int = 3, max_leaves: int = 3,
+    def cart(predictor, max_depth: int = 3, max_leaves: int = 3, max_features=None,
              discretization: Iterable[DiscreteFeature] = None, normalization=None, simplify: bool = True) -> Extractor:
         """
         Creates a new Cart extractor.
         """
         from psyke.extraction.cart import Cart
-        return Cart(predictor, max_depth, max_leaves, discretization=discretization, normalization=normalization,
-                    simplify=simplify)
+        return Cart(predictor, max_depth, max_leaves, max_features,
+                    discretization=discretization, normalization=normalization, simplify=simplify)
 
     @staticmethod
     def divine(predictor, k: int = 5, patience: int = 15, close_to_center: bool = True,
@@ -289,14 +289,15 @@ class Extractor(EvaluableModel, ABC):
 
     @staticmethod
     def iter(predictor, min_update: float = 0.1, n_points: int = 1, max_iterations: int = 600, min_examples: int = 250,
-             threshold: float = 0.1, fill_gaps: bool = True, normalization: dict[str, tuple[float, float]] = None,
-             output=None, seed: int = get_default_random_seed()) -> Extractor:
+             threshold: float = 0.1, fill_gaps: bool = True, ignore_dimensions=None,
+             normalization: dict[str, tuple[float, float]] = None, output=None,
+             seed: int = get_default_random_seed()) -> Extractor:
         """
         Creates a new ITER extractor.
         """
         from psyke.extraction.hypercubic.iter import ITER
         return ITER(predictor, min_update, n_points, max_iterations, min_examples, threshold, fill_gaps,
-                    normalization, output, seed)
+                    ignore_dimensions, normalization, output, seed)
 
     @staticmethod
     def gridex(predictor, grid, min_examples: int = 250, threshold: float = 0.1, output: Target = Target.CONSTANT,

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/extraction/cart/__init__.py

@@ -1,3 +1,5 @@
+from abc import ABC
+
 from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
 
 from psyke.extraction import PedagogicalExtractor
@@ -14,26 +16,28 @@ import pandas as pd
 TREE_SEED = get_default_random_seed()
 
 
-class Cart(PedagogicalExtractor):
+class Cart(PedagogicalExtractor, ABC):
 
-    def __init__(self, predictor, max_depth: int = 3, max_leaves: int = None,
+    def __init__(self, predictor, max_depth: int = 3, max_leaves: int = None, max_features=None,
                  discretization: Iterable[DiscreteFeature] = None,
                  normalization=None, simplify: bool = True):
         super().__init__(predictor, discretization, normalization)
         self._cart_predictor = CartPredictor(normalization=normalization)
         self.depth = max_depth
         self.leaves = max_leaves
+        self.max_features = max_features
         self._simplify = simplify
 
-    def _create_body(self, variables: dict[str, Var], constraints: LeafConstraints) -> Iterable[Struct]:
+    def _create_body(self, variables: dict[str, Var], conditions: LeafConstraints) -> Iterable[Struct]:
         results = []
-        for feature_name, constraint, value in constraints:
-            features = [d for d in self.discretization if feature_name in d.admissible_values]
-            feature: DiscreteFeature = features[0] if len(features) > 0 else None
-            results.append(create_term(variables[feature_name], constraint) if feature is None else
-                           create_term(variables[feature.name],
-                                       feature.admissible_values[feature_name],
-                                       isinstance(constraint, GreaterThan)))
+        for feature_name, cond_list in conditions.items():
+            for condition in cond_list:
+                features = [d for d in self.discretization if feature_name in d.admissible_values]
+                feature: DiscreteFeature = features[0] if len(features) > 0 else None
+                results.append(create_term(variables[feature_name], condition) if feature is None else
+                               create_term(variables[feature.name],
+                                           feature.admissible_values[feature_name],
+                                           isinstance(condition, GreaterThan)))
         return results
 
     @staticmethod
@@ -41,11 +45,12 @@ class Cart(PedagogicalExtractor):
         simplified = [nodes.pop(0)]
         while len(nodes) > 0:
             first_node = nodes[0][0]
-            for condition in first_node:
-                if all([condition in [node[0] for node in nodes][i] for i in range(len(nodes))]):
-                    [node[0].remove(condition) for node in nodes]
+            for k, conditions in first_node.items():
+                for condition in conditions:
+                    if all(k in node[0] and condition in node[0][k] for node in nodes):
+                        [node[0][k].remove(condition) for node in nodes]
             simplified.append(nodes.pop(0))
-        return simplified
+        return [({k: v for k, v in rule.items() if v != []}, prediction) for rule, prediction in simplified]
 
     def _create_theory(self, data: pd.DataFrame) -> Theory:
         new_theory = mutable_theory()
@@ -66,13 +71,26 @@ class Cart(PedagogicalExtractor):
 
     def _extract(self, data: pd.DataFrame) -> Theory:
         tree = DecisionTreeClassifier if isinstance(data.iloc[0, -1], str) else DecisionTreeRegressor
-        self._cart_predictor.predictor = tree(random_state=TREE_SEED, max_depth=self.depth, max_leaf_nodes=self.leaves)
+        self._cart_predictor.predictor = tree(random_state=TREE_SEED, max_depth=self.depth,
+                                              max_leaf_nodes=self.leaves, max_features=self.max_features)
         self._cart_predictor.predictor.fit(data.iloc[:, :-1], data.iloc[:, -1])
         return self._create_theory(data)
 
     def _predict(self, dataframe: pd.DataFrame) -> Iterable:
         return self._cart_predictor.predict(dataframe)
 
+    def predict_why(self, data: dict[str, float], verbose=True):
+        prediction = None
+        conditions = {}
+        if self.normalization is not None:
+            data = {k: v * self.normalization[k][1] + self.normalization[k][0] if k in self.normalization else v
+                    for k, v in data.items()}
+        for conditions, prediction in self._cart_predictor:
+            if all(all(interval.is_in(data[variable]) for interval in intervals)
+                   for variable, intervals in conditions.items()):
+                break
+        return prediction, conditions
+
     @property
     def n_rules(self) -> int:
         return self._cart_predictor.n_leaves

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/extraction/cart/predictor.py

@@ -2,9 +2,9 @@ from collections import Iterable
 from typing import Union, Any
 import numpy as np
 from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
-from psyke.schema import Value, LessThan, GreaterThan
+from psyke.schema import Value, LessThan, GreaterThan, SchemaException
 
-LeafConstraints = list[tuple[str, Value, bool]]
+LeafConstraints = dict[str, list[Value]]
 LeafSequence = Iterable[tuple[LeafConstraints, Any]]
 
 
@@ -25,8 +25,17 @@ class CartPredictor:
         if self.normalization is not None:
             thresholds = [threshold * self.normalization[feature][1] + self.normalization[feature][0]
                           for feature, threshold in zip(features, thresholds)]
-        return [(feature, LessThan(threshold) if condition else GreaterThan(threshold), condition)
-                for feature, condition, threshold in zip(features, conditions, thresholds)]
+        cond_dict = {}
+        for feature, condition, threshold in zip(features, conditions, thresholds):
+            cond = LessThan(threshold) if condition else GreaterThan(threshold)
+            if feature in cond_dict:
+                try:
+                    cond_dict[feature][-1] *= cond
+                except SchemaException:
+                    cond_dict[feature].append(cond)
+            else:
+                cond_dict[feature] = [cond]
+        return cond_dict
 
     def __get_leaves(self) -> Iterable[int]:
         return [i for i, (left_child, right_child) in enumerate(zip(
@@ -39,7 +48,8 @@ class CartPredictor:
         else:
             return self._predictor.tree_.value[node]
 
-    def __path(self, node: int, path=[]) -> Iterable[(int, bool)]:
+    def __path(self, node: int, path=None) -> Iterable[(int, bool)]:
+        path = [] if path is None else path
         if node == 0:
             return path
         father = list(self._left_children if node in self._left_children else self._right_children).index(node)

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/extraction/hypercubic/iter/__init__.py

@@ -16,8 +16,9 @@ class ITER(HyperCubeExtractor):
     """
 
     def __init__(self, predictor, min_update, n_points, max_iterations, min_examples, threshold, fill_gaps,
-                 normalization, output: Target = Target.CONSTANT, seed=get_default_random_seed()):
-        super().__init__(predictor, output, normalization)
+                 ignore_dimensions: Iterable, normalization, output: Target = Target.CONSTANT,
+                 seed=get_default_random_seed()):
+        super().__init__(predictor, output, normalization=normalization)
         if output is Target.REGRESSION:
             raise NotImplementedError
         self.predictor = predictor
@@ -30,6 +31,7 @@ class ITER(HyperCubeExtractor):
         self._output = Target.CLASSIFICATION if isinstance(predictor, ClassifierMixin) else \
             output if output is not None else Target.CONSTANT
         self.seed = seed
+        self.ignore_dimensions = ignore_dimensions if ignore_dimensions is not None else []
 
     def _best_cube(self, dataframe: pd.DataFrame, cube: GenericCube, cubes: Iterable[Expansion]) -> Expansion | None:
         expansions = []
@@ -74,6 +76,8 @@ class ITER(HyperCubeExtractor):
                            hypercubes: Iterable[GenericCube]) -> Iterable[Expansion]:
         tmp_cubes = []
         for feature in self._surrounding.dimensions.keys():
+            if feature in self.ignore_dimensions:
+                continue
             limit = cube.check_limits(feature)
             if limit == '*':
                 continue
@@ -132,6 +136,8 @@ class ITER(HyperCubeExtractor):
             hypercubes = self._generate_starting_points(dataframe)
             for hypercube in hypercubes:
                 hypercube.expand_all(min_updates, self._surrounding)
+                for d in self.ignore_dimensions:
+                    hypercube[d] = self._surrounding[d]
             self.n_points = self.n_points - 1
             if not HyperCube.check_overlap(hypercubes, hypercubes):
                 break

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/schema/__init__.py

@@ -3,14 +3,27 @@ import math
 from typing import Callable
 from psyke.utils import get_int_precision
 
+
+class SchemaException(Exception):
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
 _EMPTY_INTERSECTION_EXCEPTION: Callable = lambda x, y: \
-    Exception(f"Empty intersection between two Value: {str(x)} and {str(y)}")
+    SchemaException(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))
+    SchemaException(f"Not implemented intersection between: {str(x)} and {str(y)}")
 
-_INTERSECTION_WITH_WRONG_TYPE: Callable = lambda x, y: \
-    Exception("Calling method with wrong type argument: " + str(x) + ' and ' + str(y))
+_OPERATION_WITH_WRONG_TYPE: Callable = lambda x, y: \
+    SchemaException("Calling method with wrong type argument: " + str(x) + ' and ' + str(y))
+
+_EMPTY_UNION_EXCEPTION: Callable = lambda x, y: \
+    SchemaException(f"Empty union between two Value: {str(x)} and {str(y)}")
+
+_NOT_IMPLEMENTED_UNION: Callable = lambda x, y: \
+    SchemaException("Not implemented union between: " + str(x) + ' and ' + str(y))
 
 PRECISION = get_int_precision()
 STRING_PRECISION = str(PRECISION)
@@ -109,7 +122,7 @@ class Value:
                 else:
                     raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_outside(first_value: Outside, second_value: Value) -> Value:
             if isinstance(first_value, Outside):
@@ -154,9 +167,9 @@ class Value:
                 elif isinstance(second_value, Constant):
                     return intersection_with_constant(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_between(first_value: Between, second_value: Value) -> Value:
             if isinstance(first_value, Between):
@@ -194,9 +207,9 @@ class Value:
                 elif isinstance(second_value, Outside):
                     return intersection_with_outside(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_less_than(first_value: LessThan, second_value: Value) -> Value:
             if isinstance(first_value, LessThan):
@@ -214,9 +227,9 @@ class Value:
                 elif isinstance(second_value, Between):
                     return intersection_with_between(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
             if isinstance(first_value, GreaterThan):
@@ -231,9 +244,9 @@ class Value:
                 elif isinstance(second_value, LessThan):
                     return intersection_with_less_than(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         if other is None:
             return self
@@ -248,7 +261,151 @@ class Value:
         elif isinstance(self, GreaterThan):
             return intersection_with_greater_than(self, other)
         else:
-            raise _INTERSECTION_WITH_WRONG_TYPE(self, other)
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
+
+    def __add__(self, other) -> Value:
+
+        def union_with_constant(first_value: Constant, second_value: Value) -> Value:
+            if isinstance(first_value, Constant):
+                if first_value in second_value:
+                    return second_value
+                else:
+                    raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_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.upper:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value > first_value.lower:
+                        return Outside(second_value.value, first_value.upper)
+                    else:
+                        return first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value < first_value.lower:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value < first_value.upper:
+                        return Outside(first_value.lower, second_value.value)
+                    else:
+                        return first_value
+                elif isinstance(second_value, Between):
+                    if second_value.upper <= first_value.lower or second_value.lower >= first_value.upper:
+                        return first_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(second_value.upper, first_value.lower)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(first_value.upper, second_value.lower)
+                    elif second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Outside):
+                    if second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return first_value
+                    elif first_value.lower <= second_value.lower <= second_value.upper <= first_value.upper:
+                        return second_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(first_value.lower, second_value.upper)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(second_value.lower, first_value.upper)
+                    else:
+                        return Between(-math.inf, math.inf)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_between(first_value: Between, second_value: Value) -> Value:
+            if isinstance(first_value, Between):
+                if isinstance(second_value, LessThan):
+                    if second_value.value <= first_value.lower:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return LessThan(first_value.upper)
+                    else:
+                        return second_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.lower:
+                        return second_value
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return GreaterThan(first_value.lower)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Between):
+                    if second_value in first_value:
+                        return first_value
+                    elif first_value in second_value:
+                        return second_value
+                    elif first_value.lower <= second_value.lower <= first_value.upper:
+                        return Between(first_value.lower, second_value.upper)
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Between(second_value.lower, first_value.upper)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_less_than(first_value: LessThan, second_value: Value) -> Value:
+            if isinstance(first_value, LessThan):
+                if isinstance(second_value, LessThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.value:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        return Outside(first_value.value, second_value.value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
+            if isinstance(first_value, GreaterThan):
+                if isinstance(second_value, GreaterThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                elif isinstance(second_value, LessThan):
+                    return union_with_less_than(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        if other is None:
+            return self
+        elif isinstance(self, Constant):
+            return union_with_constant(self, other)
+        elif isinstance(self, Outside):
+            return union_with_outside(self, other)
+        elif isinstance(self, Between):
+            return union_with_between(self, other)
+        elif isinstance(self, LessThan):
+            return union_with_less_than(self, other)
+        elif isinstance(self, GreaterThan):
+            return union_with_greater_than(self, other)
+        else:
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
 
     def print(self) -> str:
         pass

{psyke-0.8.6.dev2 → psyke-0.8.9}/psyke/tuning/pedro/__init__.py

@@ -98,14 +98,15 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
         return False
 
     def search(self):
+        max_partitions = 200
         base_partitions = FixedStrategy(2).partition_number(self.dataframe.columns[:-1]) * 3
-        if base_partitions <= 50:
+        if base_partitions <= max_partitions:
             strategies = [FixedStrategy(2)]
-            if FixedStrategy(3).partition_number(self.dataframe.columns[:-1]) <= base_partitions:
+            if FixedStrategy(3).partition_number(self.dataframe.columns[:-1]) <= max_partitions:
                 strategies.append(FixedStrategy(3))
         else:
             strategies = []
-            base_partitions = 50
+            base_partitions = max_partitions
 
         for n in [2, 3, 5, 10]:
             for th in [0.99, 0.75, 0.67, 0.5, 0.3]:

{psyke-0.8.6.dev2 → psyke-0.8.9/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.6.dev2
+Version: 0.8.9
 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.6.dev2/VERSION

@@ -1 +0,0 @@
-0.8.6.dev2