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

psyke/extraction/cart/FairTreePredictor.py

@@ -0,0 +1,56 @@
+import copy
+from typing import Union, Any
+
+from psyke.extraction.cart import FairTreeClassifier, FairTreeRegressor, LeafSequence, LeafConstraints
+from psyke.extraction.cart.CartPredictor import CartPredictor
+from psyke.schema import LessThan, GreaterThan, SchemaException, Value
+
+
+class FairTreePredictor(CartPredictor):
+    """
+    A wrapper for fair decision and regression trees of psyke.
+    """
+
+    def __init__(self, predictor: Union[FairTreeClassifier, FairTreeRegressor] = FairTreeClassifier(),
+                 discretization=None, normalization=None):
+        super().__init__(predictor, discretization, normalization)
+
+    def __iter__(self) -> LeafSequence:
+        leaves = [node for node in self.recurse(self._predictor.root, {})]
+        return (leaf for leaf in leaves)
+
+    @staticmethod
+    def merge_constraints(constraints: LeafConstraints, constraint: Value, feature: str):
+        if feature in constraints:
+            try:
+                constraints[feature][-1] *= constraint
+            except SchemaException:
+                constraints[feature].append(constraint)
+        else:
+            constraints[feature] = [constraint]
+        return constraints
+
+    def recurse(self, node, constraints) -> Union[LeafSequence, tuple[LeafConstraints, Any]]:
+        if node.is_leaf_node():
+            return constraints, node.value
+
+        feature = node.feature
+        threshold = node.threshold if self.normalization is None else \
+            (node.threshold * self.normalization[feature][1] + self.normalization[feature][0])
+
+        left = self.recurse(node.left, self.merge_constraints(copy.deepcopy(constraints), LessThan(threshold), feature))
+        right = self.recurse(node.right, self.merge_constraints(copy.deepcopy(constraints),
+                                                                GreaterThan(threshold), feature))
+        return (left if isinstance(left, list) else [left]) + (right if isinstance(right, list) else [right])
+
+    @property
+    def predictor(self) -> Union[FairTreeClassifier, FairTreeRegressor]:
+        return self._predictor
+
+    @property
+    def n_leaves(self) -> int:
+        return self._predictor.n_leaves
+
+    @predictor.setter
+    def predictor(self, predictor: Union[FairTreeClassifier, FairTreeRegressor]):
+        self._predictor = predictor

psyke/extraction/cart/__init__.py

@@ -3,78 +3,53 @@ from abc import ABC
 from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
 
 from psyke.extraction import PedagogicalExtractor
-from psyke.extraction.cart.predictor import CartPredictor, LeafConstraints, LeafSequence
 from psyke import get_default_random_seed
-from psyke.schema import GreaterThan, DiscreteFeature
-from psyke.utils.logic import create_variable_list, create_head, create_term
-from tuprolog.core import clause, Var, Struct
-from tuprolog.theory import Theory, mutable_theory
-from typing import Iterable
+from psyke.extraction.cart.FairTree import FairTreeClassifier, FairTreeRegressor
+from psyke.schema import DiscreteFeature, Value
+from tuprolog.theory import Theory
+from typing import Iterable, Any
 import pandas as pd
 
 
 TREE_SEED = get_default_random_seed()
 
+LeafConstraints = dict[str, list[Value]]
+LeafSequence = Iterable[tuple[LeafConstraints, Any]]
+
 
 class Cart(PedagogicalExtractor, ABC):
 
     def __init__(self, predictor, max_depth: int = 3, max_leaves: int = None, max_features=None,
                  discretization: Iterable[DiscreteFeature] = None,
                  normalization=None, simplify: bool = True):
+        from psyke.extraction.cart.CartPredictor import CartPredictor
+
         super().__init__(predictor, discretization, normalization)
-        self._cart_predictor = CartPredictor(normalization=normalization)
+        self.is_fair = None
+        self._cart_predictor = CartPredictor(discretization=discretization, 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], conditions: LeafConstraints) -> Iterable[Struct]:
-        results = []
-        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
-    def _simplify_nodes(nodes: list) -> Iterable:
-        simplified = [nodes.pop(0)]
-        while len(nodes) > 0:
-            first_node = nodes[0][0]
-            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 [({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()
-        nodes = [node for node in self._cart_predictor]
-        nodes = Cart._simplify_nodes(nodes) if self._simplify else nodes
-        for (constraints, prediction) in nodes:
-            if self.normalization is not None and data.columns[-1] in self.normalization:
-                m, s = self.normalization[data.columns[-1]]
-                prediction = prediction * s + m
-            variables = create_variable_list(self.discretization, data)
-            new_theory.assertZ(
-                clause(
-                    create_head(data.columns[-1], list(variables.values()), prediction),
-                    self._create_body(variables, constraints)
-                )
-            )
-        return new_theory
-
     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, max_features=self.max_features)
+        from psyke.extraction.cart.FairTreePredictor import FairTreePredictor
+
+        if self.is_fair:
+            self._cart_predictor = FairTreePredictor(discretization=self.discretization,
+                                                     normalization=self.normalization)
+            fair_tree = FairTreeClassifier if isinstance(data.iloc[0, -1], str) else FairTreeRegressor
+            self._cart_predictor.predictor = fair_tree(max_depth=self.depth, max_leaves=self.leaves,
+                                                       protected_attr=self.is_fair)
+        else:
+            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, max_features=self.max_features)
         self._cart_predictor.predictor.fit(data.iloc[:, :-1], data.iloc[:, -1])
-        return self._create_theory(data)
+        return self._cart_predictor.create_theory(data, self._simplify)
+
+    def make_fair(self, features: Iterable[str]):
+        self.is_fair = features
 
     def _predict(self, dataframe: pd.DataFrame) -> Iterable:
         return self._cart_predictor.predict(dataframe)

psyke/extraction/hypercubic/__init__.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-import math
 from abc import ABC
+from collections.abc import Iterable
+from itertools import combinations
+
 import numpy as np
 import pandas as pd
 from sklearn.base import ClassifierMixin
@@ -13,7 +15,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.schema import Between, Outside, Value
+from psyke.schema import Value
 from psyke.utils.logic import create_variable_list, create_head, to_var, Simplifier
 from psyke.utils import Target
 from psyke.extraction.hypercubic.strategy import Strategy, FixedStrategy
@@ -24,19 +26,62 @@ class HyperCubeExtractor(HyperCubePredictor, PedagogicalExtractor, ABC):
         HyperCubePredictor.__init__(self, output=output, normalization=normalization)
         PedagogicalExtractor.__init__(self, predictor, discretization=discretization, normalization=normalization)
         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],
+                      adjacent_cache: dict[tuple[HyperCube, HyperCube], str | None]) -> \
+            Iterable[tuple[HyperCube, HyperCube, str]]:
+
+        for cube1, cube2 in combinations(to_split, 2):
+            key = (cube1, cube2) if id(cube1) < id(cube2) else (cube2, cube1)
+
+            if (cube1 in not_in_cache) or (cube2 in not_in_cache):
+                adjacent_cache[key] = cube1.is_adjacent(cube2)
+            feature = adjacent_cache.get(key)
+            if feature is not None:
+                yield cube1, cube2, feature
+
+    def _evaluate_merge(self, not_in_cache: Iterable[HyperCube], dataframe: pd.DataFrame, feature: str,
+                        cube: HyperCube, other_cube: HyperCube,
+                        merge_cache: dict[tuple[HyperCube, HyperCube], HyperCube | None]) -> bool:
+        if (cube in not_in_cache) or (other_cube in not_in_cache):
+            merged_cube = cube.merge_along_dimension(other_cube, feature)
+            merged_cube.update(dataframe, self.predictor)
+            merge_cache[(cube, other_cube)] = merged_cube
+        return cube.output == other_cube.output if self._output == Target.CLASSIFICATION else \
+            merge_cache[(cube, other_cube)].diversity < self.threshold
 
     def _sort_cubes(self):
         cubes = [(cube.diversity, i, cube) for i, cube in enumerate(self._hypercubes)]
         cubes.sort()
         self._hypercubes = [cube[2] for cube in cubes]
 
+    def _merge(self, to_split: list[HyperCube], dataframe: pd.DataFrame) -> Iterable[HyperCube]:
+        not_in_cache = set(to_split)
+        adjacent_cache = {}
+        merge_cache = {}
+        while True:
+            to_merge = [([cube, other_cube], merge_cache[(cube, other_cube)]) for cube, other_cube, feature in
+                        HyperCubeExtractor._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
+            best = min(to_merge, key=lambda c: c[1].diversity)
+            for cube in best[0]:
+                to_split.remove(cube)
+            to_split.append(best[1])
+            not_in_cache = [best[1]]
+        return to_split
+
     def extract(self, dataframe: pd.DataFrame) -> Theory:
         theory = PedagogicalExtractor.extract(self, dataframe)
         self._surrounding = HyperCube.create_surrounding_cube(dataframe, output=self._output)
@@ -209,10 +254,16 @@ class FeatureRanker:
 
 
 class Grid:
-    def __init__(self, iterations: int = 1, strategy: Strategy | list[Strategy] = FixedStrategy()):
+    def __init__(self, iterations: int = 1, strategy: Strategy | Iterable[Strategy] = FixedStrategy()):
         self.iterations = iterations
         self.strategy = strategy
 
+    def make_fair(self, features: Iterable[str]):
+        if isinstance(self.strategy, Strategy):
+            self.strategy.make_fair(features)
+        elif isinstance(self.strategy, Iterable):
+            [strategy.make_fair(features) for strategy in self.strategy]
+
     def get(self, feature: str, depth: int) -> int:
         if isinstance(self.strategy, list):
             return self.strategy[depth].get(feature)

psyke/extraction/hypercubic/creepy/__init__.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from collections import Iterable
-import numpy as np
+from collections.abc import Iterable
+from typing import Callable, Any
+
 import pandas as pd
 from sklearn.base import ClassifierMixin
 from tuprolog.theory import Theory
@@ -16,16 +17,23 @@ class CReEPy(HyperCubeExtractor):
     Explanator implementing CReEPy algorithm.
     """
 
-    def __init__(self, predictor, clustering=Clustering.exact, depth: int = 3, error_threshold: float = 0.1,
-                 output: Target = Target.CONSTANT, gauss_components: int = 5, ranks: list[(str, float)] = [],
-                 ignore_threshold: float = 0.0, discretization=None, normalization=None,
-                 seed: int = get_default_random_seed()):
+    ClusteringType = Callable[[int, float, Target, int, Any, Any, int], HyperCubeClustering]
+
+    def __init__(self, predictor, clustering: ClusteringType = Clustering.exact, depth: int = 3,
+                 error_threshold: float = 0.1, output: Target = Target.CONSTANT, gauss_components: int = 5,
+                 ranks: Iterable[(str, float)] = tuple(), ignore_threshold: float = 0.0, discretization=None,
+                 normalization=None, seed: int = get_default_random_seed()):
         super().__init__(predictor, Target.CLASSIFICATION if isinstance(predictor, ClassifierMixin) else output,
                          discretization, normalization)
         self.clustering = clustering(depth, error_threshold, self._output, gauss_components, discretization,
                                      normalization, seed)
         self._default_surrounding_cube = True
         self._dimensions_to_ignore = set([dimension for dimension, relevance in ranks if relevance < ignore_threshold])
+        self._protected_features = []
+
+    def make_fair(self, features: Iterable[str]):
+        self.clustering.make_fair(features)
+        self._dimensions_to_ignore.update(features)
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
         if not isinstance(self.clustering, HyperCubeClustering):

psyke/extraction/hypercubic/ginger/__init__.py

@@ -0,0 +1,100 @@
+import itertools
+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, Target
+from psyke.extraction.hypercubic import HyperCubeExtractor, HyperCube, RegressionCube
+
+from deap import base, creator
+
+from psyke.genetic.gin import GIn
+
+
+class GInGER(HyperCubeExtractor):
+    """
+    Explanator implementing GInGER algorithm.
+    """
+
+    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,
+                 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)
+
+        self.features = features
+        self.max_features = len(features)
+        self.sigmas = sigmas
+        self.max_slices = max_slices
+        self.min_rules = min_rules
+        self.poly = max_poly
+        self.trained_poly = None
+
+        self.alpha = alpha
+        self.indpb = indpb
+        self.tournsize = tournsize
+        self.metric = metric
+
+        self.n_gen = n_gen
+        self.n_pop = n_pop
+        self.valid = valid
+
+        creator.create("FitnessMax", base.Fitness, weights=(1.0,))
+        creator.create("Individual", list, fitness=creator.FitnessMax)
+
+    def __poly_names(self):
+        return [''.join(['' if pp == 0 else f'{n} * ' if pp == 1 else f'{n}**{pp} * '
+                         for pp, n in zip(p, self.trained_poly.feature_names_in_)])[:-3]
+                for p in self.trained_poly.powers_]
+
+    def _predict(self, dataframe: pd.DataFrame) -> Iterable:
+        dataframe = pd.DataFrame(self.trained_poly.fit_transform(dataframe), columns=self.__poly_names())
+        return np.array([self._predict_from_cubes(row.to_dict()) for _, row in dataframe.iterrows()])
+
+    def _extract(self, dataframe: pd.DataFrame) -> Theory:
+        best = {}
+        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, 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
+        m = min(best)
+        poly, slices, best = m[1], m[2], best[m]
+        self.trained_poly = PolynomialFeatures(degree=poly, include_bias=False)
+        transformed = pd.DataFrame(self.trained_poly.fit_transform(dataframe.iloc[:, :-1]), columns=self.__poly_names())
+        transformed[dataframe.columns[-1]] = dataframe.iloc[:, -1].values
+
+        self._surrounding = HyperCube.create_surrounding_cube(transformed, output=self._output)
+
+        cuts = [sorted(best[sum(slices[:i]):sum(slices[:i + 1])]) for i in range(len(slices))]
+
+        intervals = [[(transformed[self.features[i]].min(), cut[0])] +
+                     [(cut[i], cut[i + 1]) for i in range(len(cut) - 1)] +
+                     [(cut[-1], transformed[self.features[i]].max())] for i, cut in enumerate(cuts)]
+
+        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 = [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:
+                if feature not in self.features:
+                    for direction in ['+', '-']:
+                        c.set_infinite(feature, direction)
+            c.update(transformed)
+        if self.threshold is not None:
+            self._hypercubes = self._merge(self._hypercubes, transformed)
+        return self._create_theory(transformed)
+
+    def make_fair(self, features: Iterable[str]):
+        self._dimensions_to_ignore.update(features)

psyke/extraction/hypercubic/gridex/__init__.py

@@ -59,7 +59,6 @@ class GridEx(HyperCubeExtractor):
     def _iterate(self, dataframe: pd.DataFrame):
         fake = dataframe.copy()
         prev = [self._surrounding]
-        next_iteration = []
 
         for iteration in self.grid.iterate():
             next_iteration = []
@@ -67,53 +66,12 @@ class GridEx(HyperCubeExtractor):
                 if cube.count(dataframe) == 0:
                     continue
                 if cube.diversity < self.threshold:
-                    self._hypercubes += [cube]
+                    self._hypercubes.append(cube)
                     continue
                 to_split, fake = self._cubes_to_split(cube, 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]
+                next_iteration.extend(self._merge(to_split, fake))
+            prev = next_iteration
+        self._hypercubes.extend(prev)
 
-    @staticmethod
-    def _find_couples(to_split: Iterable[HyperCube], not_in_cache: Iterable[HyperCube],
-                      adjacent_cache: dict[tuple[HyperCube, HyperCube], str | None]) -> \
-            Iterable[tuple[HyperCube, HyperCube, str]]:
-        checked = []
-        eligible = []
-        for cube in to_split:
-            checked.append(cube)
-            for other_cube in [c for c in to_split if c not in checked]:
-                if (cube in not_in_cache) or (other_cube in not_in_cache):
-                    adjacent_cache[(cube, other_cube)] = cube.is_adjacent(other_cube)
-                adjacent_feature = adjacent_cache[(cube, other_cube)]
-                eligible.append((cube, other_cube, adjacent_feature))
-        return [couple for couple in eligible if couple[2] is not None]
-
-    def _evaluate_merge(self, not_in_cache: Iterable[HyperCube],
-                        dataframe: pd.DataFrame, feature: str,
-                        cube: HyperCube, other_cube: HyperCube,
-                        merge_cache: dict[(HyperCube, HyperCube), HyperCube | None]) -> bool:
-        if (cube in not_in_cache) or (other_cube in not_in_cache):
-            merged_cube = cube.merge_along_dimension(other_cube, feature)
-            merged_cube.update(dataframe, self.predictor)
-            merge_cache[(cube, other_cube)] = merged_cube
-        return cube.output == other_cube.output if self._output == Target.CLASSIFICATION else \
-            merge_cache[(cube, other_cube)].diversity < self.threshold
-
-    def _merge(self, to_split: Iterable[HyperCube], dataframe: pd.DataFrame) -> Iterable[HyperCube]:
-        not_in_cache = [cube for cube in to_split]
-        adjacent_cache = {}
-        merge_cache = {}
-        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:
-                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
+    def make_fair(self, features: Iterable[str]):
+        self.grid.make_fair(features)

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/extraction/hypercubic/hypercube.py

@@ -143,10 +143,9 @@ class HyperCube:
         self._default = True
 
     def set_infinite(self, dimension: str, direction: str):
-        if dimension in self._infinite_dimensions:
-            self._infinite_dimensions[dimension].append(direction)
-        else:
-            self._infinite_dimensions[dimension] = [direction]
+        if dimension not in self._infinite_dimensions:
+            self._infinite_dimensions[dimension] = set()
+        self._infinite_dimensions[dimension].add(direction)
 
     def copy_infinite_dimensions(self, dimensions: dict[str, str]):
         self._infinite_dimensions = dimensions.copy()
@@ -260,13 +259,15 @@ class HyperCube:
                 if not self.is_default and value is not None]
 
     @staticmethod
-    def create_surrounding_cube(dataset: pd.DataFrame, closed: bool = False,
-                                output=None) -> GenericCube:
+    def create_surrounding_cube(dataset: pd.DataFrame, closed: bool = False, output=None,
+                                features_to_ignore: Iterable[str] = []) -> GenericCube:
         output = Target.CONSTANT if output is None else output
         dimensions = {
             column: (min(dataset[column]) - HyperCube.EPSILON * 2, max(dataset[column]) + HyperCube.EPSILON * 2)
             for column in dataset.columns[:-1]
         }
+        for column in features_to_ignore:
+            dimensions[column] = (-np.inf, np.inf)
         if closed:
             if output == Target.CONSTANT:
                 return ClosedCube(dimensions)
@@ -432,14 +433,16 @@ class HyperCube:
         else:
             self.update_dimension(feature, (lower, upper))
 
-    def update(self, dataset: pd.DataFrame, predictor) -> None:
-        filtered = self.filter_dataframe(dataset.iloc[:, :-1])
-        predictions = predictor.predict(filtered)
-        self._output = np.mean(predictions)
-        self._diversity = np.std(predictions)
-        self._error = (abs(predictions - self._output)).mean()
-        means = filtered.describe().loc['mean']
-        self._barycenter = Point(means.index.values, means.values)
+    def update(self, dataset: pd.DataFrame, predictor=None) -> None:
+        idx = self.filter_indices(dataset.iloc[:, :-1])
+        filtered = dataset.iloc[idx, :-1]
+        if len(filtered > 0):
+            predictions = dataset.iloc[idx, -1] if predictor is None else predictor.predict(filtered)
+            self._output = np.mean(predictions)
+            self._diversity = np.std(predictions)
+            self._error = (abs(predictions - self._output)).mean()
+            means = filtered.describe().loc['mean']
+            self._barycenter = Point(means.index.values, means.values)
 
     # TODO: why this is not a property?
     def init_diversity(self, std: float) -> None:
@@ -450,10 +453,11 @@ class RegressionCube(HyperCube):
     def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output=None):
         super().__init__(dimension=dimension, limits=limits, output=LinearRegression() if output is None else output)
 
-    def update(self, dataset: pd.DataFrame, predictor) -> None:
-        filtered = self.filter_dataframe(dataset.iloc[:, :-1])
+    def update(self, dataset: pd.DataFrame, predictor=None) -> None:
+        idx = self.filter_indices(dataset.iloc[:, :-1])
+        filtered = dataset.iloc[idx, :-1]
         if len(filtered > 0):
-            predictions = predictor.predict(filtered)
+            predictions = dataset.iloc[idx, -1] if predictor is None else predictor.predict(filtered)
             self._output.fit(filtered, predictions)
             self._diversity = self._error = (abs(self._output.predict(filtered) - predictions)).mean()
             means = filtered.describe().loc['mean']
@@ -471,12 +475,14 @@ class RegressionCube(HyperCube):
         return new_cube
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
-        intercept = self.output.intercept_ if normalization is None else unscale(sum(
-            [-self.output.coef_[i] * normalization[name][0] / normalization[name][1] for i, name in
-             enumerate(self.dimensions.keys())], self.output.intercept_), list(normalization.keys())[-1])
-        coefs = self.output.coef_ if normalization is None else [
-            self.output.coef_[i] / normalization[name][1] * normalization[list(normalization.keys())[-1]][1] for
-            i, name in enumerate(self.dimensions.keys())
+        intercept = self.output.intercept_
+        intercept = np.array(intercept).flatten()[0] if isinstance(intercept, Iterable) else intercept
+        intercept = intercept if normalization is None else unscale(sum(
+            [-self.output.coef_.flatten()[i] * normalization[name][0] / normalization[name][1] for i, name in
+             enumerate(self.dimensions.keys())], intercept), list(normalization.keys())[-1])
+        coefs = self.output.coef_.flatten() if normalization is None else [
+            self.output.coef_.flatten()[i] / normalization[name][1] * normalization[list(normalization.keys())[-1]][1]
+            for i, name in enumerate(self.dimensions.keys())
         ]
         return list(super().body(variables, ignore, unscale, normalization)) + [linear_function_creator(
             list(variables.values()), [to_rounded_real(v) for v in coefs], to_rounded_real(intercept)
@@ -487,10 +493,11 @@ class ClassificationCube(HyperCube):
     def __init__(self, dimension: dict[str, tuple] = None, limits: set[Limit] = None, output: str = ""):
         super().__init__(dimension=dimension, limits=limits, output=output)
 
-    def update(self, dataset: pd.DataFrame, predictor) -> None:
-        filtered = self.filter_dataframe(dataset.iloc[:, :-1])
+    def update(self, dataset: pd.DataFrame, predictor=None) -> None:
+        idx = self.filter_indices(dataset.iloc[:, :-1])
+        filtered = dataset.iloc[idx, :-1]
         if len(filtered > 0):
-            predictions = predictor.predict(filtered)
+            predictions = dataset.iloc[idx, -1] if predictor is None else predictor.predict(filtered)
             self._output = mode(predictions)
             self._diversity = self._error = 1 - sum(p == self.output for p in predictions) / len(predictions)
             means = filtered.describe().loc['mean']

psyke/extraction/hypercubic/iter/__init__.py

@@ -23,6 +23,7 @@ class ITER(HyperCubeExtractor):
             raise NotImplementedError
         self.predictor = predictor
         self.min_update = min_update
+        self._init_points = n_points
         self.n_points = n_points
         self.max_iterations = max_iterations
         self.min_examples = min_examples
@@ -33,6 +34,10 @@ class ITER(HyperCubeExtractor):
         self.seed = seed
         self.ignore_dimensions = ignore_dimensions if ignore_dimensions is not None else []
 
+    def make_fair(self, features: Iterable[str]):
+        self.n_points = self._init_points
+        self.ignore_dimensions += list(features)
+
     def _best_cube(self, dataframe: pd.DataFrame, cube: GenericCube, cubes: Iterable[Expansion]) -> Expansion | None:
         expansions = []
         for limit in cubes: