psyke 0.10.1.dev3__tar.gz → 0.10.1.dev6__tar.gz

{psyke-0.10.1.dev3/psyke.egg-info → psyke-0.10.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.10.1.dev3
+Version: 0.10.1.dev6
 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.10.1.dev6/VERSION

@@ -0,0 +1 @@
+0.10.1.dev6

{psyke-0.10.1.dev3 → psyke-0.10.1.dev6}/psyke/__init__.py

@@ -396,8 +396,8 @@ class Extractor(EvaluableModel, ABC):
 
     @staticmethod
     def ginger(predictor, features: Iterable[str], sigmas: Iterable[float], max_slices: int, min_rules: int = 1,
-               max_poly: int = 1, alpha: float = 0.5, indpb: float = 0.5, tournsize: int = 3, metric:str = 'R2',
-               n_gen: int = 50, n_pop: int = 50, threshold=None, valid=None,
+               max_poly: int = 1, alpha: float = 0.5, indpb: float = 0.5, tournsize: int = 3, metric: str = 'R2',
+               n_gen: int = 50, n_pop: int = 50, threshold=None, valid=None, output=Target.REGRESSION,
                normalization: dict[str, tuple[float, float]] = None,
                seed: int = get_default_random_seed()) -> Extractor:
         """
@@ -405,7 +405,7 @@ class Extractor(EvaluableModel, ABC):
         """
         from psyke.extraction.hypercubic.ginger import GInGER
         return GInGER(predictor, features, sigmas, max_slices, min_rules, max_poly, alpha, indpb, tournsize, metric,
-                      n_gen, n_pop, threshold, valid, normalization, seed)
+                      n_gen, n_pop, threshold, valid, output, normalization, seed)
 
     @staticmethod
     def gridrex(predictor, grid, min_examples: int = 250, threshold: float = 0.1,

{psyke-0.10.1.dev3 → psyke-0.10.1.dev6}/psyke/extraction/hypercubic/__init__.py

@@ -28,12 +28,12 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         self._default_surrounding_cube = False
         self.threshold = None
 
-    def _default_cube(self) -> HyperCube | RegressionCube | ClassificationCube:
+    def _default_cube(self, dimensions=None) -> HyperCube | RegressionCube | ClassificationCube:
         if self._output == Target.CONSTANT:
-            return HyperCube()
+            return HyperCube(dimensions)
         if self._output == Target.REGRESSION:
-            return RegressionCube()
-        return ClassificationCube()
+            return RegressionCube(dimensions)
+        return ClassificationCube(dimensions)
 
     @staticmethod
     def _find_couples(to_split: Iterable[HyperCube], not_in_cache: set[HyperCube],

{psyke-0.10.1.dev3 → psyke-0.10.1.dev6}/psyke/extraction/hypercubic/ginger/__init__.py

@@ -3,10 +3,11 @@ from typing import Iterable
 
 import numpy as np
 import pandas as pd
+from sklearn.base import ClassifierMixin
 from sklearn.preprocessing import PolynomialFeatures
 from tuprolog.theory import Theory
 
-from psyke import get_default_random_seed
+from psyke import get_default_random_seed, Target
 from psyke.extraction.hypercubic import HyperCubeExtractor, HyperCube, RegressionCube
 
 from deap import base, creator
@@ -20,9 +21,10 @@ class GInGER(HyperCubeExtractor):
     """
 
     def __init__(self, predictor, features, sigmas, max_slices, min_rules=1, max_poly=1, alpha=0.5, indpb=0.5,
-                 tournsize=3, metric='R2', n_gen=50, n_pop=50, threshold=None, valid=None, normalization=None,
-                 seed: int = get_default_random_seed()):
-        super().__init__(predictor, normalization)
+                 tournsize=3, metric='R2', n_gen=50, n_pop=50, threshold=None, valid=None,
+                 output: Target = Target.REGRESSION, normalization=None, seed: int = get_default_random_seed()):
+        super().__init__(predictor, output=Target.CLASSIFICATION if isinstance(predictor, ClassifierMixin) else output,
+                         normalization=normalization)
         self.threshold = threshold
         np.random.seed(seed)
 
@@ -60,8 +62,8 @@ class GInGER(HyperCubeExtractor):
         for poly in range(self.poly):
             for slices in list(itertools.product(range(1, self.max_slices + 1), repeat=self.max_features)):
                 gr = GIn((dataframe.iloc[:, :-1], dataframe.iloc[:, -1]), self.valid, self.features, self.sigmas,
-                         slices, min_rules=self.min_rules, poly=poly + 1, alpha=self.alpha,
-                         indpb=self.indpb, tournsize=self.tournsize, metric=self.metric, warm=True)
+                         slices, min_rules=self.min_rules, poly=poly + 1, alpha=self.alpha, indpb=self.indpb,
+                         tournsize=self.tournsize, metric=self.metric, output=self._output, warm=True)
 
                 b, score, _, _ = gr.run(n_gen=self.n_gen, n_pop=self.n_pop)
                 best[(score, poly + 1, slices)] = b
@@ -81,8 +83,8 @@ class GInGER(HyperCubeExtractor):
 
         hypercubes = [{f: iv for f, iv in zip(self.features, combo)} for combo in itertools.product(*intervals)]
         mi_ma = {f: (transformed[f].min(), transformed[f].max()) for f in transformed.columns if f not in self.features}
-        self._hypercubes = [RegressionCube({feat: h[feat] if feat in self.features else mi_ma[feat]
-                                            for feat in transformed.columns[:-1]}) for h in hypercubes]
+        self._hypercubes = [self._default_cube({feat: h[feat] if feat in self.features else mi_ma[feat]
+                                                for feat in transformed.columns[:-1]}) for h in hypercubes]
         self._hypercubes = [c for c in self._hypercubes if c.count(transformed) >= 2]
         for c in self._hypercubes:
             for feature in transformed.columns:

{psyke-0.10.1.dev3 → psyke-0.10.1.dev6}/psyke/genetic/gin/__init__.py

@@ -1,17 +1,22 @@
+from statistics import mode
+
 import numpy as np
 from deap import base, creator, tools, algorithms
 import random
 from sklearn.linear_model import LinearRegression
-from sklearn.metrics import mean_absolute_error, r2_score
+from sklearn.metrics import mean_absolute_error, r2_score, mean_squared_error, f1_score, accuracy_score
 from sklearn.preprocessing import PolynomialFeatures
 
+from psyke import Target
+
 
 class GIn:
 
     def __init__(self, train, valid, features, sigmas, slices, min_rules=1, poly=1, alpha=0.5, indpb=0.5, tournsize=3,
-                 metric='R2', warm=False):
+                 metric='R2', output=Target.REGRESSION, warm=False):
         self.X, self.y = train
         self.valid = valid
+        self.output = output
 
         self.features = features
         self.sigmas = sigmas
@@ -42,6 +47,29 @@ class GIn:
 
         return regions
 
+    def __output_estimation(self, mask, to_pred):
+        if self.output == Target.REGRESSION:
+            return LinearRegression().fit(self.poly.fit_transform(self.X)[mask], self.y[mask]).predict(
+                self.poly.fit_transform(to_pred))
+        if self.output == Target.CONSTANT:
+            return np.mean(self.y[mask])
+        if self.output == Target.CLASSIFICATION:
+            return mode(self.y[mask])
+        raise TypeError('Supported outputs are Target.{REGRESSION, CONSTANT, CLASSIFICATION}')
+
+    def __score(self, true, pred):
+        if self.metric == 'R2':
+            return r2_score(true, pred)
+        if self.metric == 'MAE':
+            return -mean_absolute_error(true, pred)
+        if self.metric == 'MSE':
+            return -mean_squared_error(true, pred)
+        if self.metric == 'F1':
+            return f1_score(true, pred, average='weighted')
+        if self.metric == 'ACC':
+            return accuracy_score(true, pred)
+        raise NameError('Supported metrics are R2, MAE, MSE, F1, ACC')
+
     def evaluate(self, individual):
         to_pred, true = self.valid or (self.X, self.y)
         boundaries = np.cumsum([0] + list(self.slices))
@@ -50,23 +78,24 @@ class GIn:
         regions = self.region(to_pred, cuts)
         regionsT = self.region(self.X, cuts)
 
-        y_pred = np.zeros(len(to_pred))
+        y_pred = np.empty(len(to_pred), dtype=f'U{self.y.str.len().max()}') if self.output == Target.CLASSIFICATION \
+            else np.zeros_like(self.y)
         valid_regions = 0
 
         for r in range(np.prod([s + 1 for s in self.slices])):
             mask = regions == r
             maskT = regionsT == r
             if min(mask.sum(), maskT.sum()) < 3:
-                y_pred[mask] = np.mean(self.y)
+                if self.output != Target.CLASSIFICATION:
+                    y_pred[mask] = np.mean(self.y)
                 continue
-            y_pred[mask] = LinearRegression().fit(self.poly.fit_transform(self.X)[maskT], self.y[maskT]).predict(
-                self.poly.fit_transform(to_pred)[mask])
+            y_pred[mask] = self.__output_estimation(maskT, to_pred[mask])
             valid_regions += 1
 
         if valid_regions < self.min_rules:
             return -9999,
 
-        return (r2_score if self.metric == 'R2' else -mean_absolute_error)(true, y_pred),
+        return self.__score(true, y_pred),
 
     def setup(self, warm=False):
         if not warm:

{psyke-0.10.1.dev3 → psyke-0.10.1.dev6/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.10.1.dev3
+Version: 0.10.1.dev6
 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.10.1.dev3/VERSION

@@ -1 +0,0 @@
-0.10.1.dev3