psyke 0.10.1.dev11__tar.gz → 0.10.4__tar.gz

{psyke-0.10.1.dev11/psyke.egg-info → psyke-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.10.1.dev11
+Version: 0.10.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.10.4/VERSION

@@ -0,0 +1 @@
+0.10.4

{psyke-0.10.1.dev11 → psyke-0.10.4}/psyke/extraction/hypercubic/gridrex/__init__.py

@@ -5,12 +5,12 @@ from psyke.extraction.hypercubic.gridex import GridEx
 
 class GridREx(GridEx):
     """
-    Explanator implementing GridREx algorithm.
+    Explanator implementing GridREx algorithm, doi:10.24963/kr.2022/57.
     """
 
     def __init__(self, predictor, grid: Grid, min_examples: int, threshold: float, normalization,
                  seed=get_default_random_seed()):
         super().__init__(predictor, grid, min_examples, threshold, Target.REGRESSION, None, normalization, seed)
 
-    def _default_cube(self) -> RegressionCube:
+    def _default_cube(self, dimensions=None) -> RegressionCube:
         return RegressionCube()

psyke-0.10.4/psyke/genetic/fgin/__init__.py

@@ -0,0 +1,74 @@
+import numpy as np
+import pandas as pd
+
+from psyke import Target
+from psyke.genetic.gin import GIn
+
+import skfuzzy as skf
+
+
+class FGIn(GIn):
+
+    def __init__(self, train, valid, features, sigmas, slices, min_rules=1, poly=1, alpha=0.5, indpb=0.5, tournsize=3,
+                 metric='R2', output=Target.REGRESSION, warm=False):
+        super().__init__(train, valid, features, sigmas, slices, min_rules, poly, alpha, indpb, tournsize,
+                         metric, output, warm)
+        self.feature_to_idx = {f: i for i, f in enumerate(self.X.columns)}
+
+    def _evaluate(self, individual=None):
+        y_pred, valid_regions = self.__predict(individual or self.best, self.X if self.valid is None else self.valid[0])
+        if valid_regions < self.min_rules:
+            return -9999,
+        return self._score(self.y if self.valid is None else self.valid[1], y_pred),
+
+    @staticmethod
+    def __generate_membership(var, domain, thresholds, shape='tri'):
+        th = [var.min()] + [min(max(t, var.min()), var.max()) for t in thresholds] + [var.max()]
+
+        if shape == 'tri':
+            mid = [(x1 + x2) / 2 for x1, x2 in zip(th[:-1], th[1:])]
+            return [skf.trapmf(domain, [domain.min()] * 2 + mid[:2])] + \
+                   [skf.trimf(domain, [x1, x2, x3]) for x1, x2, x3 in zip(mid[:-2], mid[1:-1], mid[2:])] + \
+                   [skf.trapmf(domain, mid[-2:] + [domain.max()] * 2)]
+        if shape == 'trap':
+            beg = [None, domain.min()] + [(3 * x1 + x2) / 4 for x1, x2 in zip(th[1:-1], th[2:])] + [domain.max()]
+            end = [domain.min()] + [(x1 + 3 * x2) / 4 for x1, x2 in zip(th[:-2], th[1:-1])] + [domain.max()]
+            return [skf.trapmf(domain, [end[i - 1], beg[i], end[i], beg[i + 1]]) for i in range(1, len(th))]
+        raise ValueError('Supported shape values are only \'tri\' and \'trap\'')
+
+    @staticmethod
+    def __extend_domain(x, q_low=0.05, q_high=0.95, p=0.05, k_sigma=2.0, abs_min_margin=0.0):
+        ql, qh = np.quantile(x, [q_low, q_high])
+        margin = max(p * (qh - ql), k_sigma * np.std(x), abs_min_margin)
+        return np.array([ql - margin, qh + margin])
+
+    def __get_activations(self, x, functions_domains, valid_masks):
+        levels = [np.array([skf.interp_membership(domain, mf, x[index]) for mf in mfs])
+                  for mfs, domain, index in functions_domains.values()]
+        return np.prod(np.meshgrid(*levels, indexing='ij'), axis=0).ravel()[valid_masks]
+
+    def __fuzzify(self, cuts):
+        cuts = dict(zip(self.features, cuts))
+        doms = {c: FGIn.__extend_domain(self.X[c]) for c in self.features}
+        return {c: (FGIn.__generate_membership(self.X[c], doms[c], cuts[c], 'trap'), doms[c],
+                    self.feature_to_idx[c]) for c in self.features}
+
+    def __predict(self, individual=None, to_pred=None):
+        cuts = self._get_cuts(individual or self.best)
+        masks = np.array([self._region(to_pred, cuts) == r for r in range(np.prod([s + 1 for s in self.slices]))])
+        valid_masks = masks.sum(axis=1) >= 3
+
+        masks = [mask for mask in masks if mask.sum() >= 3]
+        functions_domains = self.__fuzzify(cuts)
+
+        pred = np.array([self._output_estimation(mask, to_pred) for mask in masks]).T
+        activations = np.array([self.__get_activations(x, functions_domains, valid_masks) for x in to_pred.values])
+
+        if self.output == Target.CLASSIFICATION:
+            classes, idx = np.unique(pred, return_inverse=True)
+            pred = classes[np.argmax(np.vstack([activations[:, idx == i].sum(axis=1) for i, c in enumerate(classes)]),
+                                     axis=0)]
+        else:
+            pred = (pred * activations).sum(axis=1)
+
+        return pd.DataFrame(pred, index=to_pred.index), len(masks)

{psyke-0.10.1.dev11 → psyke-0.10.4}/psyke/genetic/gin/__init__.py

@@ -32,14 +32,15 @@ class GIn:
         self.toolbox = None
         self.stats = None
         self.hof = None
+        self.best = None
 
-        self.setup(warm)
+        self.__setup(warm)
 
-    def region(self, X, cuts):
-        indices = [np.searchsorted(np.array(cut), X[f].to_numpy(), side='right')
+    def _region(self, x, cuts):
+        indices = [np.searchsorted(np.array(cut), x[f].to_numpy(), side='right')
                    for cut, f in zip(cuts, self.features)]
 
-        regions = np.zeros(len(X), dtype=int)
+        regions = np.zeros(len(x), dtype=int)
         multiplier = 1
         for idx, n in zip(reversed(indices), reversed([len(cut) + 1 for cut in cuts])):
             regions += idx * multiplier
@@ -47,7 +48,7 @@ class GIn:
 
         return regions
 
-    def __output_estimation(self, mask, to_pred):
+    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))
@@ -55,9 +56,9 @@ class GIn:
             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}')
+        raise ValueError('Supported outputs are Target.{REGRESSION, CONSTANT, CLASSIFICATION}')
 
-    def __score(self, true, pred):
+    def _score(self, true, pred):
         if self.metric == 'R2':
             return r2_score(true, pred)
         if self.metric == 'MAE':
@@ -68,18 +69,23 @@ class GIn:
             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')
+        raise ValueError('Supported metrics are R2, MAE, MSE, F1, ACC')
 
-    def evaluate(self, individual):
-        to_pred, true = self.valid or (self.X, self.y)
+    def predict(self, to_pred):
+        return self.__predict(to_pred=to_pred)[0]
+
+    def _get_cuts(self, individual):
         boundaries = np.cumsum([0] + list(self.slices))
-        cuts = [sorted(individual[boundaries[i]:boundaries[i + 1]]) for i in range(len(self.slices))]
+        return [sorted(individual[boundaries[i]:boundaries[i + 1]]) for i in range(len(self.slices))]
+
+    def __predict(self, individual=None, to_pred=None):
+        cuts = self._get_cuts(individual or self.best)
 
-        regions = self.region(to_pred, cuts)
-        regionsT = self.region(self.X, cuts)
+        regions = self._region(to_pred, cuts)
+        regionsT = self._region(self.X, cuts)
 
-        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)
+        pred = np.empty(len(to_pred), dtype=f'U{self.y.str.len().max()}') if self.output == Target.CLASSIFICATION \
+            else np.zeros(len(to_pred))
         valid_regions = 0
 
         for r in range(np.prod([s + 1 for s in self.slices])):
@@ -87,17 +93,20 @@ class GIn:
             maskT = regionsT == r
             if min(mask.sum(), maskT.sum()) < 3:
                 if self.output != Target.CLASSIFICATION:
-                    y_pred[mask] = np.mean(self.y)
+                    pred[mask] = np.mean(self.y)
                 continue
-            y_pred[mask] = self.__output_estimation(maskT, to_pred[mask])
+            pred[mask] = self._output_estimation(maskT, to_pred[mask])
             valid_regions += 1
 
+        return pred, valid_regions
+
+    def _evaluate(self, individual=None):
+        y_pred, valid_regions = self.__predict(individual or self.best, self.X if self.valid is None else self.valid[0])
         if valid_regions < self.min_rules:
             return -9999,
+        return self._score(self.y if self.valid is None else self.valid[1], y_pred),
 
-        return self.__score(true, y_pred),
-
-    def setup(self, warm=False):
+    def __setup(self, warm=False):
         if not warm:
             creator.create("FitnessMax", base.Fitness, weights=(1.0,))
             creator.create("Individual", list, fitness=creator.FitnessMax)
@@ -116,7 +125,7 @@ class GIn:
         self.toolbox.register("mutate", tools.mutGaussian, indpb=self.indpb, mu=0,
                               sigma=sum([[sig] * s for sig, s in zip(self.sigmas, self.slices)], []))
         self.toolbox.register("select", tools.selTournament, tournsize=self.tournsize)
-        self.toolbox.register("evaluate", self.evaluate)
+        self.toolbox.register("evaluate", self._evaluate)
 
         self.stats = tools.Statistics(lambda ind: ind.fitness.values[0])
         self.stats.register("avg", np.mean)
@@ -131,5 +140,5 @@ class GIn:
         pop = self.toolbox.population(n=n_pop)
         result, log = algorithms.eaSimple(pop, self.toolbox, cxpb=cxpb, mutpb=mutpb, ngen=n_gen,
                                           stats=self.stats, halloffame=self.hof, verbose=False)
-        best = tools.selBest(pop, 1)[0]
-        return best, self.evaluate(best)[0], result, log
+        self.best = tools.selBest(pop, 1)[0]
+        return self.best, self._evaluate()[0], result, log

{psyke-0.10.1.dev11 → psyke-0.10.4/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.10.1.dev11
+Version: 0.10.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.10.1.dev11 → psyke-0.10.4}/psyke.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ psyke/extraction/real/utils.py
 psyke/extraction/trepan/__init__.py
 psyke/extraction/trepan/utils.py
 psyke/genetic/__init__.py
+psyke/genetic/fgin/__init__.py
 psyke/genetic/gin/__init__.py
 psyke/schema/__init__.py
 psyke/tuning/__init__.py

psyke-0.10.1.dev11/VERSION

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