psyke 0.8.9.dev48__py3-none-any.whl → 1.0.4.dev10__py3-none-any.whl

psyke/extraction/hypercubic/strategy.py

@@ -1,16 +1,20 @@
 from __future__ import annotations
 
 from functools import reduce
-from typing import Iterable
+from collections.abc import Iterable
 
 
 class Strategy:
-    def __init__(self):
-        self._partitions = None
+    def __init__(self, partitions = None):
+        self._partitions = partitions
+        self._no_features = []
 
     def get(self, feature: str) -> int:
         raise NotImplementedError
 
+    def make_fair(self, features: Iterable[str]):
+        self._no_features = features
+
     def partition_number(self, features: Iterable[str]) -> int:
         return reduce(lambda x, y: x * y, map(self.get, features), 1)
 
@@ -29,23 +33,23 @@ class Strategy:
 
 class FixedStrategy(Strategy):
     def __init__(self, partitions: int = 2):
-        super().__init__()
-        self._partitions = partitions
+        super().__init__(partitions)
 
     def get(self, feature: str) -> int:
-        return self._partitions
+        return 1 if feature in self._no_features else self._partitions
 
     def __str__(self):
         return "Fixed ({})".format(super().__str__())
 
 
 class AdaptiveStrategy(Strategy):
-    def __init__(self, features: Iterable[str], partitions: Iterable[tuple[float, float]] | None = None):
-        super().__init__()
+    def __init__(self, features: Iterable[(str, float)], partitions: Iterable[tuple[float, float]] | None = None):
+        super().__init__(partitions if partitions is not None else [(0.33, 2), (0.67, 3)])
         self.features = features
-        self._partitions = partitions if partitions is not None else [(0.33, 2), (0.67, 3)]
 
     def get(self, feature: str) -> int:
+        if feature in self._no_features:
+            return 1
         importance = next(filter(lambda t: t[0] == feature, self.features))[1]
         n = 1
         for (imp, part) in self._partitions:

psyke/extraction/real/__init__.py

@@ -15,13 +15,12 @@ class REAL(PedagogicalExtractor):
     """
     Explanator implementing Rule Extraction As Learning (REAL) algorithm, doi:10.1016/B978-1-55860-335-6.50013-1.
     The algorithm is sensible to features' order in the provided dataset during extraction.
-    To make it reproducible the features are internally sorted (alphabetically).
     """
 
     def __init__(self, predictor, discretization: Iterable[DiscreteFeature]):
         super().__init__(predictor, discretization)
+        self._ignore_feature = []
         self._ruleset: IndexedRuleSet = IndexedRuleSet()
-        self._output_mapping = {}
 
     @property
     def n_rules(self):
@@ -31,7 +30,7 @@ class REAL(PedagogicalExtractor):
         new_rule = self._rule_from_example(sample)
         return any([new_rule in rule for rule in rules])
 
-    def _create_body(self, variables: dict[str, Var], rule: Rule) -> list[Struct]:
+    def _body(self, variables: dict[str, Var], rule: Rule) -> list[Struct]:
         result = []
         for predicates, truth_value in zip(rule.to_lists(), [True, False]):
             for predicate in predicates:
@@ -40,27 +39,24 @@ class REAL(PedagogicalExtractor):
         return result
 
     def _create_clause(self, dataset: pd.DataFrame, variables: dict[str, Var], key: int, rule: Rule) -> Clause:
-        head = create_head(dataset.columns[-1],
-                           sorted(list(variables.values())),
-                           str(sorted(list(set(dataset.iloc[:, -1])))[key]))
-        return clause(head, self._create_body(variables, rule))
+        return clause(create_head(dataset.columns[-1], list(variables.values()), key), self._body(variables, rule))
 
     def _create_new_rule(self, sample: pd.Series) -> Rule:
         rule = self._rule_from_example(sample)
         return self._generalise(rule, sample)
 
     def _create_ruleset(self, dataset: pd.DataFrame) -> IndexedRuleSet:
-        ruleset = IndexedRuleSet.create_indexed_ruleset(dataset)
-        for index, sample in dataset.iloc[:, :-1].iterrows():
+        ruleset = IndexedRuleSet.create_indexed_ruleset(sorted(set(dataset.iloc[:, -1])))
+        for _, sample in dataset.iloc[:, :-1].iterrows():
             prediction = list(self.predictor.predict(sample.to_frame().transpose()))[0]
-            rules = ruleset.get(self._output_mapping[prediction])
+            rules = ruleset.get(prediction)
             if not self._covers(sample, rules):
                 rules.append(self._create_new_rule(sample))
         return ruleset.optimize()
 
-    def _create_theory(self, dataset: pd.DataFrame, ruleset: IndexedRuleSet) -> MutableTheory:
+    def _create_theory(self, dataset: pd.DataFrame) -> MutableTheory:
         theory = mutable_theory()
-        for key, rule in ruleset.flatten():
+        for key, rule in self._ruleset.flatten():
             variables = create_variable_list(self.discretization)
             theory.assertZ(self._create_clause(dataset, variables, key, rule))
         return theory
@@ -92,16 +88,22 @@ class REAL(PedagogicalExtractor):
         return self._create_ruleset(dataset)
 
     def _internal_predict(self, sample: pd.Series):
-        x = [index for index, rule in self._ruleset.flatten() if REAL._rule_from_example(sample) in rule]
-        reverse_mapping = dict((v, k) for k, v in self._output_mapping.items())
-        return reverse_mapping[x[0]] if len(x) > 0 else None
+        x = [index for index, rule in self._ruleset.flatten() if self._rule_from_example(sample) in rule]
+        return x[0] if x else None
 
-    @staticmethod
-    def _rule_from_example(sample: pd.Series) -> Rule:
+    def make_fair(self, features: Iterable[str]):
+        self._ignore_feature = [list(i.admissible_values.keys()) for i in self.discretization if i.name in features] \
+            if self.discretization else [features]
+        self._ignore_feature = [feature for features in self._ignore_feature for feature in features]
+        self._get_or_set.cache_clear()
+
+    def _rule_from_example(self, sample: pd.Series) -> Rule:
         true_predicates, false_predicates = [], []
         for feature, value in sample.items():
+            if feature in self._ignore_feature:
+                continue
             true_predicates.append(str(feature)) if value == 1 else false_predicates.append(str(feature))
-        return Rule(sorted(true_predicates), sorted(false_predicates))
+        return Rule(true_predicates, false_predicates)
 
     def _subset(self, samples: pd.DataFrame, predicate: str) -> (pd.DataFrame, bool):
         samples_0 = samples.copy()
@@ -112,11 +114,8 @@ class REAL(PedagogicalExtractor):
         return samples_all, len(set(self.predictor.predict(samples_all))) == 1
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
-        # Order the dataset by column to preserve reproducibility.
-        dataframe = dataframe.sort_values(by=list(dataframe.columns.values), ascending=False)
-        self._output_mapping = {value: index for index, value in enumerate(sorted(set(dataframe.iloc[:, -1])))}
         self._ruleset = self._get_or_set(HashableDataFrame(dataframe))
-        return self._create_theory(dataframe, self._ruleset)
+        return self._create_theory(dataframe)
 
     def _predict(self, dataframe) -> Iterable:
         return np.array([self._internal_predict(data.transpose()) for _, data in dataframe.iterrows()])

psyke/extraction/real/utils.py

@@ -49,5 +49,5 @@ class IndexedRuleSet(dict[int, list[Rule]]):
         ]
 
     @staticmethod
-    def create_indexed_ruleset(dataset: pd.DataFrame) -> IndexedRuleSet:
-        return IndexedRuleSet({index: [] for index, _ in enumerate(set(dataset.iloc[:, -1]))})
+    def create_indexed_ruleset(indices: Iterable) -> IndexedRuleSet:
+        return IndexedRuleSet({i: [] for i in indices})

psyke/extraction/trepan/__init__.py

@@ -15,11 +15,17 @@ class Trepan(PedagogicalExtractor):
     def __init__(self, predictor, discretization: Iterable[DiscreteFeature], min_examples: int = 0, max_depth: int = 3,
                  split_logic: SplitLogic = SplitLogic.DEFAULT):
         super().__init__(predictor, discretization)
+        self._ignore_feature = []
         self.min_examples = min_examples
         self.max_depth = max_depth
         self.split_logic = split_logic
         self._root: Node
 
+    def make_fair(self, features: Iterable[str]):
+        self._ignore_feature = [list(i.admissible_values.keys()) for i in self.discretization if i.name in features] \
+            if self.discretization else [features]
+        self._ignore_feature = [feature for features in self._ignore_feature for feature in features]
+
     @property
     def n_rules(self):
         return sum(1 for _ in self._root)
@@ -29,7 +35,7 @@ class Trepan(PedagogicalExtractor):
             raise NotImplementedError()
         if node.n_classes == 1:
             return None
-        splits = Trepan._create_splits(node, names)
+        splits = self._create_splits(node, names)
         return None if len(splits) == 0 or splits[0].children[0].depth > self.max_depth else splits[0].children
 
     def _compact(self):
@@ -55,28 +61,26 @@ class Trepan(PedagogicalExtractor):
     def _create_split(node: Node, column: str) -> Union[Split, None]:
         true_examples = Trepan._create_samples(node, column, 1.0)
         false_examples = Trepan._create_samples(node, column, 0.0)
-        true_constrains = list(node.constraints) + [(column, 1.0)]
-        false_constrains = list(node.constraints) + [(column, 0.0)]
-        true_node = Node(true_examples, node.n_examples, true_constrains, depth=node.depth + 1)\
+        true_constraints = list(node.constraints) + [(column, 1.0)]
+        false_constraints = list(node.constraints) + [(column, 0.0)]
+        true_node = Node(true_examples, node.n_examples, true_constraints, depth=node.depth + 1) \
             if true_examples.shape[0] > 0 else None
-        false_node = Node(false_examples, node.n_examples, false_constrains, depth=node.depth + 1)\
+        false_node = Node(false_examples, node.n_examples, false_constraints, depth=node.depth + 1) \
             if false_examples.shape[0] > 0 else None
         return None if true_node is None or false_node is None else Split(node, (true_node, false_node))
 
-    @staticmethod
-    def _create_splits(node: Node, names: Iterable[str]) -> SortedList[Split]:
-        splits, constrains = Trepan._init_splits(node)
-        for column in names:
-            if column not in constrains:
-                split = Trepan._create_split(node, column)
-                if split is not None:
-                    splits.add(split)
+    def _create_splits(self, node: Node, names: Iterable[str]) -> SortedList[Split]:
+        splits, constraints = Trepan._init_splits(node)
+        for column in [column for column in names if column not in list(constraints) + self._ignore_feature]:
+            split = Trepan._create_split(node, column)
+            if split is not None:
+                splits.add(split)
         return splits
 
-    def _create_theory(self, name: str, sort: bool = True) -> MutableTheory:
+    def _create_theory(self, name: str) -> MutableTheory:
         theory = mutable_theory()
         for node in self._root:
-            variables = create_variable_list(self.discretization, sort=sort)
+            variables = create_variable_list(self.discretization)
             theory.assertZ(
                 clause(
                     create_head(name, list(variables.values()), str(node.dominant)),

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/genetic/gin/__init__.py

@@ -0,0 +1,144 @@
+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, 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', output=Target.REGRESSION, warm=False):
+        self.X, self.y = train
+        self.valid = valid
+        self.output = output
+
+        self.features = features
+        self.sigmas = sigmas
+        self.slices = slices
+        self.min_rules = min_rules
+        self.poly = PolynomialFeatures(degree=poly, include_bias=False)
+
+        self.alpha = alpha
+        self.indpb = indpb
+        self.tournsize = tournsize
+        self.metric = metric
+
+        self.toolbox = None
+        self.stats = None
+        self.hof = None
+        self.best = None
+
+        self.__setup(warm)
+
+    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)
+        multiplier = 1
+        for idx, n in zip(reversed(indices), reversed([len(cut) + 1 for cut in cuts])):
+            regions += idx * multiplier
+            multiplier *= n
+
+        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 ValueError('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 ValueError('Supported metrics are R2, MAE, MSE, F1, ACC')
+
+    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))
+        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)
+
+        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])):
+            mask = regions == r
+            maskT = regionsT == r
+            if min(mask.sum(), maskT.sum()) < 3:
+                if self.output != Target.CLASSIFICATION:
+                    pred[mask] = np.mean(self.y)
+                continue
+            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),
+
+    def __setup(self, warm=False):
+        if not warm:
+            creator.create("FitnessMax", base.Fitness, weights=(1.0,))
+            creator.create("Individual", list, fitness=creator.FitnessMax)
+
+        self.toolbox = base.Toolbox()
+        for f in self.features:
+            self.toolbox.register(f, random.uniform, self.X[f].min(), self.X[f].max())
+
+        self.toolbox.register("individual", tools.initCycle, creator.Individual,
+                              (sum([[getattr(self.toolbox, f) for i in range(s)]
+                                    for f, s in zip(self.features, self.slices)], [])), n=1)
+
+        self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
+
+        self.toolbox.register("mate", tools.cxBlend, alpha=self.alpha)
+        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.stats = tools.Statistics(lambda ind: ind.fitness.values[0])
+        self.stats.register("avg", np.mean)
+        # self.stats.register("min", np.min)
+        self.stats.register("max", np.max)
+        # self.stats.register("std", np.std)
+
+        self.hof = tools.HallOfFame(1)
+
+    def run(self, n_pop=30, cxpb=0.8, mutpb=0.5, n_gen=50, seed=123):
+        random.seed(seed)
+        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)
+        self.best = tools.selBest(pop, 1)[0]
+        return self.best, self._evaluate()[0], result, log

psyke/hypercubepredictor.py

@@ -45,9 +45,9 @@ class HyperCubePredictor(EvaluableModel):
         idx = tree.query([list(row.values())], k=1)[1][0][0]
         return HyperCubePredictor._get_cube_output(cubes[idx], row)
 
-    def _brute_predict_surface(self, row: dict[str, float]) -> GenericCube:
+    def _brute_predict_surface(self, row: pd.Series) -> GenericCube:
         return min([(
-            cube.surface_distance(Point(list(row.keys()), list(row.values()))), cube.volume(), cube
+            cube.surface_distance(Point(list(row.keys()), list(row.values))), cube.volume(), cube
         ) for cube in self._hypercubes])[-1]
 
     def _create_brute_tree(self, criterion: str = 'center', n: int = 2) -> (BallTree, list[GenericCube]):
@@ -76,6 +76,8 @@ class HyperCubePredictor(EvaluableModel):
             return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
 
     def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        if not self._hypercubes:
+            return None
         data = data.copy()
         for dimension in self._dimensions_to_ignore:
             if dimension in data:

psyke/tuning/pedro/__init__.py

@@ -55,8 +55,10 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
         patience = self.patience
         while patience > 0:
             print("{}. {}. Threshold = {:.2f}. ".format(self.algorithm_name, grid, threshold), end="")
-            extractor = self.algorithm(self.predictor, grid, min_examples=25, output=self.output,
-                                       threshold=threshold, normalization=self.normalization)
+            param_dict = dict(min_examples=25, threshold=threshold, normalization=self.normalization)
+            if self.algorithm != Extractor.gridrex:
+                param_dict['output'] = self.output
+            extractor = self.algorithm(self.predictor, grid, **param_dict)
             _ = extractor.extract(self.dataframe)
             error_function = (lambda *x: 1 - extractor.accuracy(*x)) if self.output == Target.CLASSIFICATION \
                 else extractor.mae

psyke/utils/logic.py

@@ -123,14 +123,10 @@ def to_var(name: str) -> Var:
     return var(name[0].upper() + name[1:])
 
 
-def create_variable_list(features: list[DiscreteFeature], dataset: pd.DataFrame = None, sort: bool = True) -> dict[str, Var]:
-    if sort:
-        features = sorted(features, key=lambda x: x.name)
-        dataset = sorted(dataset.columns[:-1]) if dataset is not None else None
-    else:
-        dataset = dataset.columns[:-1] if dataset is not None else None
+def create_variable_list(features: list[DiscreteFeature], dataset: pd.DataFrame = None) -> dict[str, Var]:
+    dataset = dataset.columns[:-1] if dataset is not None else None
     values = {feature.name: to_var(feature.name) for feature in features} \
-        if len(features) > 0 else {name: to_var(name) for name in dataset}
+        if features else {name: to_var(name) for name in dataset}
     return values
 
 
@@ -325,4 +321,4 @@ def get_not_in_rule(min_included: bool = False, max_included: bool = True) -> Cl
     parser = DEFAULT_CLAUSES_PARSER
     theory = parser.parse_clauses(not_in_textual_rule(LE if min_included else L, GE if max_included else G),
                                   operators=None)
-    return theory[0]
+    return theory[0]

{psyke-0.8.9.dev48.dist-info → psyke-1.0.4.dev10.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: psyke
-Version: 0.8.9.dev48
+Version: 1.0.4.dev10
 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
@@ -16,33 +16,55 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Prolog
-Requires-Python: >=3.9.0, <3.10
+Requires-Python: ==3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy~=1.26.0
-Requires-Dist: pandas~=2.2.0
-Requires-Dist: scikit-learn~=1.5.0
+Requires-Dist: numpy~=2.3.4
+Requires-Dist: pandas~=2.3.0
+Requires-Dist: scikit-learn~=1.8.0
 Requires-Dist: 2ppy~=0.4.0
 Requires-Dist: kneed~=0.8.1
 Requires-Dist: sympy~=1.11
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # PSyKE
 
 ![PSyKE Logo](.img/logo-wide.png)
 
-Some quick links:
+Quick links:
 * [Home Page](https://apice.unibo.it/xwiki/bin/view/PSyKE/)
 * [GitHub Repository](https://github.com/psykei/psyke-python)
 * [PyPi Repository](https://pypi.org/project/psyke/)
 * [Issues](https://github.com/psykei/psyke-python/issues)
 
+## Latest Releases
+
+* PSyKE 1.0: Compatibility with Python 3.11.x
+* PSyKE 0.10: New genetic algorithms for knowledge extraction
+* PSyKE 0.9: Fairness mitigation support for knowedge extractors
+* PSyKE 0.8: New features: local explainability and counterfactual support
+* PSyKE 0.7: New SKE algorithms implemented
+
 ## Intro
 
 [PSyKE](https://apice.unibo.it/xwiki/bin/view/PSyKE/) (Platform for Symbolic Knowledge Extraction)
-is intended as a library for extracting symbolic knowledge (in the form of logic rules) out of sub-symbolic predictors.
+is intended as a library for extracting symbolic knowledge (in the form of logic rule lists) out of sub-symbolic predictors.
 
 More precisely, PSyKE offers a general purpose API for knowledge extraction, and a number of different algorithms implementing it,
 supporting both classification and regression problems.
@@ -91,16 +113,14 @@ We are working on PSyKE to extend its features to encompass explainable clusteri
 
 ### End users
 
-PSyKE is deployed as a library on Pypi, and it can therefore be installed as Python package by running:
+PSyKE is deployed as a library on Pypi. It can be installed as Python package by running:
 ```bash
 pip install psyke
 ```
 
 #### Requirements
-* `numpy`
-* `pandas`
-* `scikit-learn`
-* `2ppy`
+
+Please refer to the [requirements file](https://github.com/psykei/psyke-python/blob/master/requirements.txt)
 
 ##### Test requirements
 * `skl2onnx`
@@ -108,15 +128,15 @@ pip install psyke
 * `parameterized`
 
 Once installed, it is possible to create an extractor from a predictor 
-(e.g. Neural Network, Support Vector Machine, K-Nearest Neighbor, Random Forest, etc.)
-and from the dataset used to train the predictor.
+(e.g. Neural Network, Support Vector Machine, K-Nearest Neighbours, Random Forest, etc.)
+and from the data set used to train the predictor.
 
 > **Note:** the predictor must expose a method named `predict` to be properly used as an oracle.
 
 #### End users
 
 A brief example is presented in `demo.py` script in the `demo/` folder.
-Using `sklearn`'s Iris dataset we train a K-Nearest Neighbor to predict the correct output class.
+Using `sklearn`'s Iris data set we train a K-Nearest Neighbours to predict the correct output class.
 Before training, we make the dataset discrete.
 After that we create two different extractors: REAL and Trepan.
 We output the extracted theory for both extractors.
@@ -142,8 +162,8 @@ iris(PetalLength8, PetalWidth8, SepalLength8, SepalWidth8, setosa) :- true.
 ## Developers
 
 Working with PSyKE codebase requires a number of tools to be installed:
-* Python 3.9
-  + Python version greater than `3.9.x` are currently __not__ supported
+* Python 3.11
+  + Python version >= `3.12.x` are currently __not__ supported
 
 * JDK 11+ (please ensure the `JAVA_HOME` environment variable is properly configured)
 * Git 2.20+