psyke 0.6.1.dev4__tar.gz → 0.7.5.dev5__tar.gz

{psyke-0.6.1.dev4/psyke.egg-info → psyke-0.7.5.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.6.1.dev4
+Version: 0.7.5.dev5
 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
@@ -23,8 +23,8 @@ Requires-Python: >=3.9.0, <3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy~=1.26.0
-Requires-Dist: pandas~=2.1.0
-Requires-Dist: scikit-learn~=1.3.0
+Requires-Dist: pandas~=2.2.0
+Requires-Dist: scikit-learn~=1.4.0
 Requires-Dist: 2ppy~=0.4.0
 Requires-Dist: kneed~=0.8.1
 Requires-Dist: sympy~=1.11

psyke-0.7.5.dev5/VERSION

@@ -0,0 +1 @@
+0.7.5.dev5

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/__init__.py

@@ -291,14 +291,24 @@ class Extractor(EvaluableModel, ABC):
                     normalization, output, seed)
 
     @staticmethod
-    def gridex(predictor, grid, min_examples: int = 250, threshold: float = 0.1,
-               normalization: dict[str, tuple[float, float]] = None,
+    def gridex(predictor, grid, min_examples: int = 250, threshold: float = 0.1, output: Target = Target.CONSTANT,
+               discretization=None, normalization: dict[str, tuple[float, float]] = None,
                seed: int = get_default_random_seed()) -> Extractor:
         """
         Creates a new GridEx extractor.
         """
         from psyke.extraction.hypercubic.gridex import GridEx
-        return GridEx(predictor, grid, min_examples, threshold, normalization, seed)
+        return GridEx(predictor, grid, min_examples, threshold, output, discretization, normalization, seed)
+
+    @staticmethod
+    def hex(predictor, grid, min_examples: int = 250, threshold: float = 0.1, output: Target = Target.CONSTANT,
+            discretization=None, normalization: dict[str, tuple[float, float]] = None,
+            seed: int = get_default_random_seed()) -> Extractor:
+        """
+        Creates a new HEx extractor.
+        """
+        from psyke.extraction.hypercubic.hex import HEx
+        return HEx(predictor, grid, min_examples, threshold, output, discretization, normalization, seed)
 
     @staticmethod
     def gridrex(predictor, grid, min_examples: int = 250, threshold: float = 0.1,

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/__init__.py

@@ -26,11 +26,7 @@ class PedagogicalExtractor(Extractor, ABC):
         new_y = pd.DataFrame(new_y).set_index(dataframe.index)
         data = dataframe.iloc[:, :-1].copy().join(new_y)
         data.columns = dataframe.columns
-        theory = self._extract(data, mapping, sort)
-        if isinstance(self, HyperCubeExtractor):
-            self._surrounding = HyperCube.create_surrounding_cube(dataframe, output=self._output)
-            self._surrounding.update(dataframe, self.predictor)
-        return theory
+        return self._extract(data, mapping, sort)
 
     def _extract(self, dataframe: pd.DataFrame, mapping: dict[str: int] = None, sort: bool = True) -> Theory:
         raise NotImplementedError('extract')

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/__init__.py

@@ -14,7 +14,7 @@ from psyke.extraction import PedagogicalExtractor
 from psyke.extraction.hypercubic.hypercube import HyperCube, RegressionCube, ClassificationCube, ClosedCube, Point, \
     GenericCube
 from psyke.hypercubepredictor import HyperCubePredictor
-from psyke.utils.logic import create_variable_list, create_head, to_var, Simplifier
+from psyke.utils.logic import create_variable_list, create_head, to_var, Simplifier, last_in_body
 from psyke.utils import Target
 from psyke.extraction.hypercubic.strategy import Strategy, FixedStrategy
 
@@ -24,6 +24,7 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         HyperCubePredictor.__init__(self, output=output, normalization=normalization)
         PedagogicalExtractor.__init__(self, predictor, discretization=discretization, normalization=normalization)
         self._surrounding = None
+        self._default_surrounding_cube = False
 
     def _default_cube(self) -> HyperCube | RegressionCube | ClassificationCube:
         if self._output == Target.CONSTANT:
@@ -37,14 +38,30 @@ 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, mapping: dict[str: int] = None, sort: bool = True) -> Theory:
+        theory = PedagogicalExtractor.extract(self, dataframe, mapping, sort)
+        self._surrounding = HyperCube.create_surrounding_cube(dataframe, output=self._output)
+        self._surrounding.update(dataframe, self.predictor)
+        return theory
+
     @staticmethod
     def _create_head(dataframe: pd.DataFrame, variables: list[Var], output: float | LinearRegression) -> Struct:
         return create_head(dataframe.columns[-1], variables[:-1], output) \
             if not isinstance(output, LinearRegression) else \
             create_head(dataframe.columns[-1], variables[:-1], variables[-1])
 
-    def _ignore_dimensions(self) -> Iterable[str]:
-        return []
+    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]
@@ -59,9 +76,10 @@ 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(), self.unscale, self.normalization)
+            body = cube.body(variables, self._ignore_dimensions(cube), self.unscale, self.normalization)
             new_theory.assertZ(clause(head, body))
-        return HyperCubeExtractor._prettify_theory(new_theory)
+        new_theory = HyperCubeExtractor._prettify_theory(new_theory)
+        return self._last_cube_as_default(new_theory) if self._default_surrounding_cube else new_theory
 
     @staticmethod
     def _prettify_theory(theory: Theory) -> Theory:

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/creepy/__init__.py

@@ -4,13 +4,11 @@ from collections import Iterable
 import numpy as np
 import pandas as pd
 from sklearn.base import ClassifierMixin
-from tuprolog.core import clause
 from tuprolog.theory import Theory
 from psyke import Clustering
 from psyke.clustering import HyperCubeClustering
 from psyke.extraction.hypercubic import HyperCubeExtractor
 from psyke.utils import Target, get_default_random_seed
-from psyke.utils.logic import last_in_body
 
 
 class CReEPy(HyperCubeExtractor):
@@ -28,6 +26,7 @@ class CReEPy(HyperCubeExtractor):
                                      normalization, seed)
         self.ranks = ranks
         self.ignore_threshold = ignore_threshold
+        self._default_surrounding_cube = True
 
     def _extract(self, dataframe: pd.DataFrame, mapping: dict[str: int] = None, sort: bool = True) -> Theory:
         if not isinstance(self.clustering, HyperCubeClustering):
@@ -36,17 +35,7 @@ class CReEPy(HyperCubeExtractor):
         self.clustering.fit(dataframe)
         self._hypercubes = self.clustering.get_hypercubes()
         for cube in self._hypercubes:
-            for dimension in self._ignore_dimensions():
-                cube[dimension] = [-np.inf, np.inf]
-        theory = self._create_theory(dataframe)
-        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 _ignore_dimensions(self) -> Iterable[str]:
-        return [dimension for dimension, relevance in self.ranks if relevance < self.ignore_threshold]
+            for dimension, relevance in self.ranks:
+                if relevance < self.ignore_threshold:
+                    cube[dimension] = [-np.inf, np.inf]
+        return self._create_theory(dataframe)

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/gridex/__init__.py

@@ -4,6 +4,7 @@ from itertools import product
 from typing import Iterable
 import numpy as np
 import pandas as pd
+from sklearn.base import ClassifierMixin
 from tuprolog.theory import Theory
 from psyke import get_default_random_seed
 from psyke.utils import Target
@@ -15,26 +16,45 @@ class GridEx(HyperCubeExtractor):
     Explanator implementing GridEx algorithm, doi:10.1007/978-3-030-82017-6_2.
     """
 
-    def __init__(self, predictor, grid: Grid, min_examples: int, threshold: float, normalization=None,
-                 seed=get_default_random_seed()):
-        super().__init__(predictor, Target.CONSTANT, normalization=normalization)
+    def __init__(self, predictor, grid: Grid, min_examples: int, threshold: float, output: Target = Target.CONSTANT,
+                 discretization=None, normalization=None, seed: int = get_default_random_seed()):
+        super().__init__(predictor, Target.CLASSIFICATION if isinstance(predictor, ClassifierMixin) else output,
+                         discretization, normalization)
         self.grid = grid
         self.min_examples = min_examples
         self.threshold = threshold
-        self.__generator = rnd.Random(seed)
+        self._generator = rnd.Random(seed)
 
     def _extract(self, dataframe: pd.DataFrame, mapping: dict[str: int] = None, sort: bool = True) -> Theory:
         self._hypercubes = []
-        if isinstance(np.array(self.predictor.predict(dataframe.iloc[0:1, :-1])).flatten()[0], str):
-            self._output = Target.CLASSIFICATION
         surrounding = HyperCube.create_surrounding_cube(dataframe, output=self._output)
         surrounding.init_diversity(2 * self.threshold)
         self._iterate(surrounding, dataframe)
         return self._create_theory(dataframe, sort)
 
-    def _ignore_dimensions(self) -> Iterable[str]:
-        cube = self._hypercubes[0]
-        return [d for d in cube.dimensions if all(c[d] == cube[d] for c in self._hypercubes)]
+    def _create_ranges(self, cube, iteration):
+        ranges = {}
+        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)]
+            else:
+                size = (b - a) / n_bins
+                ranges[feature] = [(a + size * i, a + size * (i + 1)) for i in range(n_bins)]
+        return ranges
+
+    def _cubes_to_split(self, cube, surrounding, iteration, dataframe, fake, keep_empty=False):
+        to_split = []
+        for (pn, p) in enumerate(list(product(*self._create_ranges(cube, iteration).values()))):
+            cube = self._default_cube()
+            for i, f in enumerate(dataframe.columns[:-1]):
+                cube.update_dimension(f, p[i])
+            n = cube.count(dataframe)
+            if n > 0 or keep_empty:
+                fake = pd.concat([fake, cube.create_samples(self.min_examples - n, surrounding, self._generator)])
+                cube.update(fake, self.predictor)
+                to_split.append(cube)
+        return to_split, fake
 
     def _iterate(self, surrounding: HyperCube, dataframe: pd.DataFrame):
         fake = dataframe.copy()
@@ -44,31 +64,13 @@ class GridEx(HyperCubeExtractor):
         for iteration in self.grid.iterate():
             next_iteration = []
             for cube in prev:
-                to_split = []
                 if cube.count(dataframe) == 0:
                     continue
                 if cube.diversity < self.threshold:
                     self._hypercubes += [cube]
                     continue
-                ranges = {}
-                for (feature, (a, b)) in cube.dimensions.items():
-                    bins = []
-                    n_bins = self.grid.get(feature, iteration)
-                    size = (b - a) / n_bins
-                    for i in range(n_bins):
-                        bins.append((a + size * i, a + size * (i + 1)))
-                    ranges[feature] = bins
-                for (pn, p) in enumerate(list(product(*ranges.values()))):
-                    cube = self._default_cube()
-                    for i, f in enumerate(dataframe.columns[:-1]):
-                        cube.update_dimension(f, p[i])
-                    n = cube.count(dataframe)
-                    if n > 0:
-                        fake = pd.concat([fake, cube.create_samples(self.min_examples - n, self.__generator)])
-                        cube.update(fake, self.predictor)
-                        to_split += [cube]
-                to_split = self._merge(to_split, fake)
-                next_iteration += [cube for cube in to_split]
+                to_split, fake = self._cubes_to_split(cube, surrounding, iteration, dataframe, fake)
+                next_iteration += [c for c in self._merge(to_split, fake)]
             prev = next_iteration.copy()
         self._hypercubes += [cube for cube in next_iteration]
 
@@ -102,15 +104,16 @@ class GridEx(HyperCubeExtractor):
         not_in_cache = [cube for cube in to_split]
         adjacent_cache = {}
         merge_cache = {}
-        # TODO: refactor this. A while true with a break is as ugly as hunger.
-        while True:
+        cont = True
+        while cont:
             to_merge = [([cube, other_cube], merge_cache[(cube, other_cube)]) for cube, other_cube, feature in
                         GridEx._find_couples(to_split, not_in_cache, adjacent_cache) if
                         self._evaluate_merge(not_in_cache, dataframe, feature, cube, other_cube, merge_cache)]
             if len(to_merge) == 0:
-                break
-            sorted(to_merge, key=lambda c: c[1].diversity)
-            best = to_merge[0]
-            to_split = [cube for cube in to_split if cube not in best[0]] + [best[1]]
-            not_in_cache = [best[1]]
+                cont = False
+            else:
+                sorted(to_merge, key=lambda c: c[1].diversity)
+                best = to_merge[0]
+                to_split = [cube for cube in to_split if cube not in best[0]] + [best[1]]
+                not_in_cache = [best[1]]
         return to_split

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/gridrex/__init__.py

@@ -1,4 +1,4 @@
-from psyke import get_default_random_seed
+from psyke import get_default_random_seed, Target
 from psyke.extraction.hypercubic import Grid, RegressionCube
 from psyke.extraction.hypercubic.gridex import GridEx
 
@@ -10,7 +10,7 @@ class GridREx(GridEx):
 
     def __init__(self, predictor, grid: Grid, min_examples: int, threshold: float, normalization,
                  seed=get_default_random_seed()):
-        super().__init__(predictor, grid, min_examples, threshold, normalization, seed)
+        super().__init__(predictor, grid, min_examples, threshold, Target.REGRESSION, None, normalization, seed)
 
     def _default_cube(self) -> RegressionCube:
         return RegressionCube()

psyke-0.7.5.dev5/psyke/extraction/hypercubic/hex/__init__.py

@@ -0,0 +1,54 @@
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+
+from psyke import get_default_random_seed, Target
+from psyke.extraction.hypercubic import Grid, HyperCube, GenericCube, ClassificationCube
+from psyke.extraction.hypercubic.gridex import GridEx
+
+
+class HEx(GridEx):
+    """
+    Explanator implementing HEx algorithm.
+    """
+
+    def __init__(self, predictor, grid: Grid, min_examples: int, threshold: float, output: Target = Target.CONSTANT,
+                 discretization=None, normalization=None, seed: int = get_default_random_seed()):
+        super().__init__(predictor, grid, min_examples, threshold, output, discretization, normalization, seed)
+        self._default_surrounding_cube = True
+
+    def _different_output(self, this_cube: GenericCube, other_cube: GenericCube) -> bool:
+        if isinstance(this_cube.output, str) and this_cube.output == other_cube.output:
+            return False
+        if isinstance(this_cube.output, float) and abs(this_cube.output - other_cube.output) < self.threshold:
+            return False
+        if isinstance(this_cube.output, LinearRegression):
+            raise NotImplementedError
+        return True
+
+    def _gain(self, parent_cube: GenericCube, new_cube: GenericCube) -> float:
+        if isinstance(parent_cube, ClassificationCube):
+            return parent_cube.output != new_cube.output
+        return parent_cube.diversity - new_cube.diversity > self.threshold / 3.0
+
+    def _iterate(self, surrounding: HyperCube, dataframe: pd.DataFrame):
+        fake = dataframe.copy()
+        surrounding.update(dataframe, self.predictor)
+        prev = [surrounding]
+        next_iteration = []
+
+        for iteration in self.grid.iterate():
+            next_iteration = []
+            for cube in prev:
+                # subcubes =
+                # [c for c in self._merge(self._cubes_to_split(cube, iteration, dataframe, fake, True), fake)]
+                subcubes, fake = self._cubes_to_split(cube, surrounding, iteration, dataframe, fake, True)
+                cleaned = [c for c in subcubes if c.count(dataframe) > 0 and self._gain(cube, c)]
+                if len(subcubes) > len(cleaned):
+                    if len(cleaned) > 0:
+                        idx = np.any([c.filter_indices(fake.iloc[:, :-1]) for c in cleaned], axis=0)
+                        cube.update(fake[~idx], self.predictor)
+                    self._hypercubes = [cube] + self._hypercubes
+                next_iteration += self._merge(cleaned, fake)
+            prev = next_iteration.copy()
+        self._hypercubes = [cube for cube in next_iteration] + self._hypercubes

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/hypercube.py

@@ -158,8 +158,9 @@ class HyperCube:
             return '*'
         raise Exception('Too many limits for this feature')
 
-    def create_samples(self, n: int = 1, generator: Random = Random(get_default_random_seed())) -> pd.DataFrame:
-        return pd.DataFrame([self._create_tuple(generator) for _ in range(n)])
+    def create_samples(self, n: int = 1, surrounding: GenericCube = None,
+                       generator: Random = Random(get_default_random_seed())) -> pd.DataFrame:
+        return pd.DataFrame([self._create_tuple(generator, surrounding) for _ in range(n)])
 
     @staticmethod
     def check_overlap(to_check: Iterable[HyperCube], hypercubes: Iterable[HyperCube]) -> bool:
@@ -208,8 +209,10 @@ class HyperCube:
             return RegressionCube(dimensions)
         return HyperCube(dimensions)
 
-    def _create_tuple(self, generator: Random) -> dict:
-        return {k: generator.uniform(self.get_first(k), self.get_second(k)) for k in self._dimensions.keys()}
+    def _create_tuple(self, generator: Random, surrounding: GenericCube) -> dict:
+        minmax = {k: (self[k][0] if np.isfinite(self[k][0]) else surrounding[k][0],
+                      self[k][1] if np.isfinite(self[k][1]) else surrounding[k][1]) for k in self._dimensions.keys()}
+        return {k: generator.uniform(minmax[k][0], minmax[k][1]) for k in self._dimensions.keys()}
 
     @staticmethod
     def cube_from_point(point: dict[str, float], output=None) -> GenericCube:

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/extraction/hypercubic/iter/__init__.py

@@ -38,7 +38,8 @@ class ITER(HyperCubeExtractor):
         expansions = []
         for limit in cubes:
             count = limit.cube.count(dataframe)
-            dataframe = pd.concat([dataframe, limit.cube.create_samples(self.min_examples - count, self.__generator)])
+            dataframe = pd.concat([dataframe, limit.cube.create_samples(self.min_examples - count,
+                                                                        generator=self.__generator)])
             limit.cube.update(dataframe, self.predictor)
             expansions.append(Expansion(
                 limit.cube, limit.feature, limit.direction,

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/tuning/pedro/__init__.py

@@ -13,7 +13,8 @@ from psyke.tuning import Objective, IterativeOptimizer, SKEOptimizer
 class PEDRO(SKEOptimizer, IterativeOptimizer):
     class Algorithm(Enum):
         GRIDEX = 1,
-        GRIDREX = 2
+        GRIDREX = 2,
+        HEX = 3
 
     def __init__(self, predictor, dataframe: pd.DataFrame, max_error_increase: float = 1.2,
                  min_rule_decrease: float = 0.9, readability_tradeoff: float = 0.1, max_depth: int = 3,
@@ -23,7 +24,10 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
                               readability_tradeoff, patience, objective, output, normalization, discretization)
         IterativeOptimizer.__init__(self, dataframe, max_error_increase, min_rule_decrease, readability_tradeoff,
                                     max_depth, patience, output, normalization, discretization)
-        self.algorithm = algorithm
+        self.algorithm = Extractor.gridrex if algorithm == PEDRO.Algorithm.GRIDREX else \
+            Extractor.gridex if algorithm == PEDRO.Algorithm.GRIDEX else Extractor.hex
+        self.algorithm_name = "GridREx" if algorithm == PEDRO.Algorithm.GRIDREX else \
+            "GridEx" if algorithm == PEDRO.Algorithm.GRIDEX else "HEx"
         self.ranked = FeatureRanker(dataframe.columns[:-1]).fit(predictor, dataframe.iloc[:, :-1]).rankings()
         predictions = self.predictor.predict(dataframe.iloc[:, :-1]).flatten()
         expected = self.dataframe.iloc[:, -1].values
@@ -50,10 +54,9 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
         params = []
         patience = self.patience
         while patience > 0:
-            print("{}. {}. Threshold = {:.2f}. ".format(self.algorithm, grid, threshold), end="")
-            extractor = Extractor.gridrex(self.predictor, grid, threshold=threshold, normalization=self.normalization) \
-                if self.algorithm == PEDRO.Algorithm.GRIDREX \
-                else Extractor.gridex(self.predictor, grid, threshold=threshold, normalization=self.normalization)
+            print("{}. {}. Threshold = {:.2f}. ".format(self.algorithm_name, grid, threshold), end="")
+            extractor = self.algorithm(self.predictor, grid, min_examples=25,
+                                       threshold=threshold, normalization=self.normalization)
             _ = extractor.extract(self.dataframe)
             error_function = (lambda *x: 1 - extractor.accuracy(*x)) if self.output == Target.CLASSIFICATION \
                 else extractor.mae

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke/utils/plot.py

@@ -44,8 +44,11 @@ def plot_classification_samples(dataframe, classes, colors, markers, labels, loc
 
 
 def plot_boundaries(extractor: HyperCubeExtractor, x: str, y: str, colors: dict[str, str],
-                    a: float = .5, h: str = '////////', ls='-', e=.05, fc='none', ec=None):
-    for cube in extractor._hypercubes:
+                    a: float = .5, h: str = '////////', ls='-', e=.05, fc='none', ec=None, reverse=False):
+    cubes = extractor._hypercubes.copy()
+    if reverse:
+        cubes.reverse()
+    for cube in cubes:
         plt.gca().fill_between((cube[x][0] - e, cube[x][1] + e), cube[y][0] - e, cube[y][1] + e,
                                fc=colors[cube.output] if fc is None else fc,
                                ec=colors[cube.output] if ec is None else ec, alpha=a, hatch=h, linestyle=ls)

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.6.1.dev4
+Version: 0.7.5.dev5
 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
@@ -23,8 +23,8 @@ Requires-Python: >=3.9.0, <3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy~=1.26.0
-Requires-Dist: pandas~=2.1.0
-Requires-Dist: scikit-learn~=1.3.0
+Requires-Dist: pandas~=2.2.0
+Requires-Dist: scikit-learn~=1.4.0
 Requires-Dist: 2ppy~=0.4.0
 Requires-Dist: kneed~=0.8.1
 Requires-Dist: sympy~=1.11

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ psyke/extraction/hypercubic/creepy/__init__.py
 psyke/extraction/hypercubic/divine/__init__.py
 psyke/extraction/hypercubic/gridex/__init__.py
 psyke/extraction/hypercubic/gridrex/__init__.py
+psyke/extraction/hypercubic/hex/__init__.py
 psyke/extraction/hypercubic/iter/__init__.py
 psyke/extraction/real/__init__.py
 psyke/extraction/real/utils.py

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/psyke.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy~=1.26.0
-pandas~=2.1.0
-scikit-learn~=1.3.0
+pandas~=2.2.0
+scikit-learn~=1.4.0
 2ppy~=0.4.0
 kneed~=0.8.1
 sympy~=1.11

{psyke-0.6.1.dev4 → psyke-0.7.5.dev5}/setup.py

@@ -15,8 +15,8 @@ EPOCHS: int = 50
 BATCH_SIZE: int = 16
 REQUIREMENTS = [
     'numpy~=1.26.0',
-    'pandas~=2.1.0',
-    'scikit-learn~=1.3.0',
+    'pandas~=2.2.0',
+    'scikit-learn~=1.4.0',
     '2ppy~=0.4.0',
     'kneed~=0.8.1',
     'sympy~=1.11'

psyke-0.6.1.dev4/VERSION

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