hgp-lib 1.2.2__tar.gz → 1.2.4__tar.gz

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hgp-lib
-Version: 1.2.2
+Version: 1.2.4
 Summary: hgp-lib: Hierarchical Genetic Programming Library for Generating Boolean Rules from Tabular Data
 Author-email: Ramona-Georgiana Albert <ramona-georgiana.albert@info.uaic.ro>, George Stoica <george.stoica@info.uaic.ro>
 Maintainer-email: George Stoica <george.stoica@info.uaic.ro>, Ramona-Georgiana Albert <ramona-georgiana.albert@info.uaic.ro>

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hgp-lib"
-version = "1.2.2"
+version = "1.2.4"
 requires-python = ">=3.10"
 description = "hgp-lib: Hierarchical Genetic Programming Library for Generating Boolean Rules from Tabular Data"
 readme = "README.md"

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/src/hgp_lib/algorithms/boolean_gp.py

@@ -75,7 +75,7 @@ class BooleanGP:
         self.score_fn = score_fn
         self.train_cm = train_cm
         self.complexity_penalty = config.complexity_penalty
-        self.train_data = train_data
+        self.train_data = np.asfortranarray(train_data)
         self.train_labels = train_labels
 
         self.current_depth = current_depth

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/src/hgp_lib/mutations/mutation_executor.py

@@ -149,13 +149,17 @@ class MutationExecutor:
             >>> str(rule)
             '0'
         """
+
         new_rule = rule.copy()
 
         last_mutation = n_mutations - 1
-        last_try = self.num_tries - 1
+        num_tries = self.num_tries
+        last_try = num_tries - 1
+        check_valid = self.check_valid
+        no_validator = check_valid is None
 
         for mutation_i in range(n_mutations):
-            for tries in range(self.num_tries):
+            for tries in range(num_tries):
                 selected = select_crossover_point(new_rule, operator_p=self.operator_p)
                 # selected = random.choice(new_rule.flatten())
 
@@ -166,11 +170,22 @@ class MutationExecutor:
                         else self.operator_mutations
                     ).apply(selected)
                 except MutationError:
+                    # TODO: Document the fact that MutationError triggers when mutations would leave the rules in
+                    #  illegal states. But a MutationError does not mean the rule has reached an illegal state
                     continue
 
-                if self.check_valid is None or self.check_valid(new_rule):
+                if no_validator:
                     rule = new_rule
                     break
-                elif mutation_i != last_mutation or tries != last_try:
-                    new_rule = rule.copy()
+                elif check_valid(new_rule):
+                    if mutation_i == last_mutation:
+                        return new_rule  # no need to copy anymore
+                    else:
+                        rule = new_rule.copy()
+                        # We copy so that future mutations that do not pass checks would not affect the rule
+                        break
+                else:
+                    # Validation failed => we need to copy the rule
+                    if mutation_i != last_mutation or tries != last_try:
+                        new_rule = rule.copy()
         return rule

hgp_lib-1.2.4/src/hgp_lib/mutations/utils.py

@@ -0,0 +1,5 @@
+class MutationError(Exception):
+    # Placeholder class used to signify that a mutation could not be executed because it would violate constraints
+    # TODO: Write in documentation that when creating mutations, mutations should not leave a rule in an invalid state.
+    # If they do, they should revert the changes and just raise MutationError
+    pass

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/src/hgp_lib/preprocessing/binarizer.py

@@ -35,6 +35,44 @@ class ColumnKind(str, Enum):
     NUMERIC = "numeric"
 
 
+def round_edges(edges: np.ndarray, values: np.ndarray) -> np.ndarray:
+    """
+    Round each finite edge to the fewest decimals, at least 2, that keep every value in
+    the same bin. The edges are returned unchanged if they would no longer increase.
+
+    Args:
+        edges (np.ndarray): Sorted bin edges, starting with ``-inf`` and ending with ``inf``.
+        values (np.ndarray): The values the edges were fitted on, without missing values.
+
+    Returns:
+        np.ndarray: The rounded edges.
+
+    Examples:
+        >>> import numpy as np
+        >>> from hgp_lib.preprocessing.binarizer import round_edges
+        >>> values = np.array([0.1602, 0.1604, 0.4, 0.6])
+        >>> round_edges(np.array([-np.inf, 0.16029999405145645, 0.51, np.inf]), values).tolist()
+        [-inf, 0.1603, 0.51, inf]
+    """
+    values = np.sort(values)
+    rounded = edges.copy()
+    for i in range(1, len(edges) - 1):
+        edge = float(edges[i])
+        below = np.searchsorted(values, edge)  # Values below the edge.
+        low = values[below - 1] if below > 0 else -np.inf
+        high = values[below] if below < len(values) else np.inf
+        decimals = 2
+        while not low < round(edge, decimals) <= high:
+            decimals += 1
+        rounded[i] = round(edge, decimals) + 0.0  # + 0.0 turns -0.0 into 0.0.
+    return rounded if np.all(np.diff(rounded) > 0) else edges
+
+
+def _cut(values: np.ndarray, edges: np.ndarray) -> np.ndarray:
+    """The index of the bin ``edges[i] <= value < edges[i + 1]`` of each value."""
+    return pd.cut(values, bins=edges, labels=False, include_lowest=True, right=False)
+
+
 class StandardBinarizer(Binarizer):
     """
     Converts a mixed-type DataFrame into a purely boolean DataFrame.
@@ -53,7 +91,7 @@ class StandardBinarizer(Binarizer):
       generalization.
     - Numeric columns are split into bins by a :class:`BinningStrategy`. When ``y`` is
       provided and no strategy is set, :class:`SupervisedTreeBinning` is used, otherwise
-      :class:`QuantileBinning`.
+      :class:`QuantileBinning`. Bins are closed on the left: ``left <= x < right``.
     - A column that contains missing values also gets a boolean ``<col>_is_NA``
       indicator column.
 
@@ -69,8 +107,7 @@ class StandardBinarizer(Binarizer):
             Per-column override for the number of bins. Keys are column names, values are
             the desired bin count (each >= 2). Default: `None`.
         precision (int):
-            Number of decimal places used when formatting numeric bin boundary names.
-            Must be >= 0. Default: `3`.
+            Deprecated and unused. Default: `3`.
         numeric_binning (BinningStrategy | None):
             Strategy for computing numeric bin edges. When `None`, the binarizer uses
             :class:`SupervisedTreeBinning` if labels are provided to ``fit_transform``
@@ -79,6 +116,10 @@ class StandardBinarizer(Binarizer):
             Whether to show progress bar. Default: `True`.
         leave_progress_bar (bool):
             Whether to leave progress bar. Default: `False`.
+        round_edges (bool):
+            Whether to round each numeric edge to the fewest decimals, at least 2, that
+            keep every training value in the same bin (see :func:`round_edges`).
+            Default: `True`.
 
 
     Examples:
@@ -92,10 +133,10 @@ class StandardBinarizer(Binarizer):
         >>> result["flag"].tolist()
         [True, False, True]
         >>> result
-            flag  val < 2.000  2.000 <= val
-        0   True         True         False
-        1  False         True         False
-        2   True        False          True
+            flag  val < 2.0  2.0 <= val
+        0   True       True       False
+        1  False      False        True
+        2   True      False        True
     """
 
     def __init__(
@@ -106,13 +147,15 @@ class StandardBinarizer(Binarizer):
         numeric_binning: BinningStrategy | None = None,
         progress_bar: bool = True,
         leave_progress_bar: bool = False,
+        round_edges: bool = True,
     ):
-        self._validate_params(num_bins, column_strategy, precision, numeric_binning)
+        self._validate_params(num_bins, column_strategy, round_edges, numeric_binning)
         self.num_bins = num_bins
         self.column_strategy = column_strategy or {}
-        self.precision = precision
+        self.precision = precision  # Deprecated: unused.
+        self.column_precision: dict[str, int] = {}  # Deprecated: unused.
+        self.round_edges = round_edges
         self.numeric_binning = numeric_binning
-        self.column_precision: dict[str, int] = {}
         self.progress_bar = progress_bar
         self.leave_progress_bar = leave_progress_bar
 
@@ -130,7 +173,7 @@ class StandardBinarizer(Binarizer):
         self,
         num_bins: int,
         column_strategy: dict[str, int] | None,
-        precision: int,
+        round_edges: bool,
         numeric_binning: BinningStrategy | None,
     ) -> None:
         check_isinstance(num_bins, int)
@@ -146,9 +189,7 @@ class StandardBinarizer(Binarizer):
                         f"Number of bins for column {col} must be an integer >= 2, is {bins}"
                     )
 
-        check_isinstance(precision, int)
-        if precision < 0:
-            raise ValueError(f"precision must be an integer >= 0, is {precision}")
+        check_isinstance(round_edges, bool)
 
         if numeric_binning is not None:
             check_isinstance(numeric_binning, BinningStrategy)
@@ -240,7 +281,7 @@ class StandardBinarizer(Binarizer):
             >>> b = StandardBinarizer(num_bins=2)
             >>> _ = b.fit_transform(pd.DataFrame({"x": [1.0, 2.0, 3.0, 4.0]}))
             >>> b.get_feature_names_out()
-            ['x < 2.500', '2.500 <= x']
+            ['x < 2.5', '2.5 <= x']
         """
         if not self._is_fitted:
             raise NotFittedError(
@@ -379,9 +420,11 @@ class StandardBinarizer(Binarizer):
 
         strategy = self._resolve_numeric_binning(y)
         edges = strategy.compute_edges(fit_values, fit_y, n_bins)
+        if self.round_edges:
+            edges = round_edges(edges, fit_values)
         self._numerical_bins[column] = edges
 
-        binned = pd.cut(values, bins=edges, labels=False, include_lowest=True)
+        binned = _cut(values, edges)
         return [
             (
                 self._format_numeric_bin_name(column, edges[i], edges[i + 1]),
@@ -417,9 +460,7 @@ class StandardBinarizer(Binarizer):
 
     def _transform_numeric(self, column: str, series: pd.Series) -> list[np.ndarray]:
         edges = self._numerical_bins[column]
-        binned = pd.cut(
-            series.to_numpy(), bins=edges, labels=False, include_lowest=True
-        )
+        binned = _cut(series.to_numpy(), edges)
         return [binned == i for i in range(len(edges) - 1)]
 
     def _resolve_numeric_binning(self, y: np.ndarray | None) -> BinningStrategy:
@@ -511,20 +552,19 @@ class StandardBinarizer(Binarizer):
         Examples:
             >>> import numpy as np
             >>> from hgp_lib.preprocessing import StandardBinarizer
-            >>> b = StandardBinarizer(precision=2)
+            >>> b = StandardBinarizer()
             >>> b._format_numeric_bin_name("x", -np.inf, 3.0)
-            'x < 3.00'
+            'x < 3.0'
             >>> b._format_numeric_bin_name("x", 1.0, np.inf)
-            '1.00 <= x'
-            >>> b._format_numeric_bin_name("x", 1.0, 3.0)
-            '1.00 <= x < 3.00'
+            '1.0 <= x'
+            >>> b._format_numeric_bin_name("x", 0.1597, 0.16029999405145645)
+            '0.1597 <= x < 0.16029999405145645'
         """
-        precision = self.column_precision.get(column, self.precision)
         if np.isneginf(left):
-            return f"{column} < {right:.{precision}f}"
+            return f"{column} < {right}"
         if np.isposinf(right):
-            return f"{left:.{precision}f} <= {column}"
-        return f"{left:.{precision}f} <= {column} < {right:.{precision}f}"
+            return f"{left} <= {column}"
+        return f"{left} <= {column} < {right}"
 
 
 if __name__ == "__main__":

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/src/hgp_lib/utils/metrics.py

@@ -38,9 +38,9 @@ def confusion_matrix(
         (1, 1, 1, 1)
     """
     if sample_weight is None:
-        tp = (y_pred & y_true).sum()
-        fp = (y_pred & ~y_true).sum()
-        total_true = y_true.sum()
+        tp = np.count_nonzero(y_pred & y_true)
+        fp = np.count_nonzero(y_pred & ~y_true)
+        total_true = np.count_nonzero(y_true)
         fn = total_true - tp
         tn = len(y_pred) - total_true - fp
     else:
@@ -80,11 +80,11 @@ def fast_f1_score(
         0.5
     """
     if sample_weight is None:
-        y_pred_sum = y_pred.sum()
-        y_true_sum = y_true.sum()
+        y_pred_sum = np.count_nonzero(y_pred)
+        y_true_sum = np.count_nonzero(y_true)
         if y_pred_sum == 0 or y_true_sum == 0:
             return 1.0 if y_pred_sum == 0 and y_true_sum == 0 else 0.0
-        return float(2 * (y_pred & y_true).sum() / (y_pred_sum + y_true_sum))
+        return float(2 * np.count_nonzero(y_pred & y_true) / (y_pred_sum + y_true_sum))
 
     y_pred_sum = np.dot(y_pred, sample_weight)
     y_true_sum = np.dot(y_true, sample_weight)

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/src/hgp_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hgp-lib
-Version: 1.2.2
+Version: 1.2.4
 Summary: hgp-lib: Hierarchical Genetic Programming Library for Generating Boolean Rules from Tabular Data
 Author-email: Ramona-Georgiana Albert <ramona-georgiana.albert@info.uaic.ro>, George Stoica <george.stoica@info.uaic.ro>
 Maintainer-email: George Stoica <george.stoica@info.uaic.ro>, Ramona-Georgiana Albert <ramona-georgiana.albert@info.uaic.ro>

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/tests/test_binarizer.py

@@ -5,6 +5,7 @@ import pandas as pd
 from sklearn.exceptions import NotFittedError
 
 from hgp_lib.preprocessing import SchemaMismatchError, StandardBinarizer
+from hgp_lib.preprocessing.binarizer import round_edges
 from hgp_lib.preprocessing.binning import (
     BinningStrategy,
     QuantileBinning,
@@ -48,14 +49,10 @@ class TestStandardBinarizer(unittest.TestCase):
         with self.assertRaises(ValueError):
             StandardBinarizer(column_strategy={"a": 1})
 
-    def test_precision_must_be_int(self):
+    def test_round_edges_must_be_bool(self):
         with self.assertRaises(TypeError):
-            StandardBinarizer(precision=1.0)
-
-    def test_precision_minimum(self):
-        with self.assertRaises(ValueError):
-            StandardBinarizer(precision=-1)
-        StandardBinarizer(precision=0)
+            StandardBinarizer(round_edges=1)
+        StandardBinarizer(round_edges=True)
 
     def test_numeric_binning_must_be_strategy(self):
         with self.assertRaises(TypeError):
@@ -154,9 +151,9 @@ class TestStandardBinarizer(unittest.TestCase):
     def test_numeric_exact_columns_and_values(self):
         df = pd.DataFrame({"x": [1.0, 2.0, 3.0, 4.0]})
         result = StandardBinarizer(num_bins=2).fit_transform(df)
-        self.assertEqual(list(result.columns), ["x < 2.500", "2.500 <= x"])
-        self.assertEqual(result["x < 2.500"].tolist(), [True, True, False, False])
-        self.assertEqual(result["2.500 <= x"].tolist(), [False, False, True, True])
+        self.assertEqual(list(result.columns), ["x < 2.5", "2.5 <= x"])
+        self.assertEqual(result["x < 2.5"].tolist(), [True, True, False, False])
+        self.assertEqual(result["2.5 <= x"].tolist(), [False, False, True, True])
 
     def test_numeric_column_strategy_override(self):
         df = pd.DataFrame({"a": range(20), "b": range(20)})
@@ -287,28 +284,94 @@ class TestStandardBinarizer(unittest.TestCase):
     #  _format_numeric_bin_name
     # ------------------------------------------------------------------ #
     def test_format_left_inf(self):
-        b = StandardBinarizer(precision=2)
-        self.assertEqual(b._format_numeric_bin_name("v", -np.inf, 3.0), "v < 3.00")
+        b = StandardBinarizer()
+        self.assertEqual(b._format_numeric_bin_name("v", -np.inf, 3.0), "v < 3.0")
 
     def test_format_right_inf(self):
-        b = StandardBinarizer(precision=2)
-        self.assertEqual(b._format_numeric_bin_name("v", 1.0, np.inf), "1.00 <= v")
+        b = StandardBinarizer()
+        self.assertEqual(b._format_numeric_bin_name("v", 1.0, np.inf), "1.0 <= v")
 
     def test_format_both_finite(self):
-        b = StandardBinarizer(precision=1)
-        self.assertEqual(b._format_numeric_bin_name("v", 1.0, 3.0), "1.0 <= v < 3.0")
-
-    def test_format_precision_zero(self):
-        b = StandardBinarizer(precision=0)
-        self.assertEqual(b._format_numeric_bin_name("x", 2.7, 5.3), "3 <= x < 5")
-
-    def test_format_column_precision_overrides_default(self):
-        b = StandardBinarizer(precision=5)
-        b.column_precision["x"] = 1
-        self.assertEqual(b._format_numeric_bin_name("x", 1.0, 2.0), "1.0 <= x < 2.0")
-        self.assertEqual(
-            b._format_numeric_bin_name("y", 1.0, 2.0), "1.00000 <= y < 2.00000"
+        b = StandardBinarizer()
+        self.assertEqual(b._format_numeric_bin_name("v", 1.5, 3.0), "1.5 <= v < 3.0")
+
+    # ------------------------------------------------------------------ #
+    #  round_edges
+    # ------------------------------------------------------------------ #
+    def test_value_on_an_edge_falls_in_the_right_bin(self):
+        class EdgeAtTwo(BinningStrategy):
+            def compute_edges(self, values, y, n_bins):
+                return np.array([-np.inf, 2.0, np.inf])
+
+        b = StandardBinarizer(numeric_binning=EdgeAtTwo())
+        result = b.fit_transform(pd.DataFrame({"x": [1.0, 2.0, 3.0]}))
+        self.assertEqual(result["2.0 <= x"].tolist(), [False, True, True])
+        test = b.transform(pd.DataFrame({"x": [2.0, np.nextafter(2.0, 0)]}))
+        self.assertEqual(test["2.0 <= x"].tolist(), [True, False])
+
+    def test_round_edges_false_keeps_the_strategy_edges(self):
+        X = pd.DataFrame({"x": [0.1597, 0.1602, 0.1604, 0.1611]})
+        y = np.array([0, 0, 1, 1])
+        b = StandardBinarizer(num_bins=2, round_edges=False)
+        b.fit_transform(X, y)
+        expected = SupervisedTreeBinning().compute_edges(X["x"].to_numpy(), y, 2)
+        np.testing.assert_array_equal(b._numerical_bins["x"], expected)
+        self.assertEqual(b.get_feature_names_out()[0], "x < 0.16030000150203705")
+
+    @staticmethod
+    def _rounded(values, *edges):
+        edges = np.array([-np.inf, *edges, np.inf])
+        return round_edges(edges, np.array(values))[1:-1].tolist()
+
+    def test_round_edges_uses_fewest_decimals(self):
+        self.assertEqual(self._rounded([0.1602, 0.1604], 0.16029999405145645), [0.1603])
+
+    def test_round_edges_keeps_at_least_two_decimals(self):
+        self.assertEqual(self._rounded([0.4, 0.6], 0.51), [0.51])
+        self.assertEqual(self._rounded([0.1, 0.2], 0.1234), [0.12])
+
+    def test_round_edges_adds_decimals_when_rounding_moves_a_value(self):
+        # 1.00 would move 1.0 to the right bin, and 2.00 would move 1.996 to the left.
+        self.assertEqual(self._rounded([1.0, 1.01], 1.004), [1.004])
+        self.assertEqual(self._rounded([1.0, 1.996], 1.9958), [1.996])
+
+    def test_round_edges_keeps_a_value_on_the_edge_in_the_right_bin(self):
+        self.assertEqual(self._rounded([1.0, 2.123456, 3.0], 2.123456), [2.12])
+
+    def test_round_edges_outside_the_data(self):
+        self.assertEqual(self._rounded([0.0, 1.0], 5.1234), [5.12])
+        self.assertEqual(self._rounded([10.0, 11.0], -3.456), [-3.46])
+
+    def test_round_edges_unchanged_when_edges_collide(self):
+        # No value lies between the two edges, so both would round to 1.5.
+        self.assertEqual(self._rounded([0.0, 1.0, 2.0], 1.5, 1.501), [1.5, 1.501])
+
+    def test_round_edges_never_moves_training_values(self):
+        from sklearn.datasets import load_breast_cancer
+
+        rng = np.random.default_rng(0)
+        random = pd.DataFrame(
+            {
+                "normal": rng.normal(size=400),
+                "ties": rng.integers(0, 6, size=400).astype(float),
+                "tiny": rng.normal(scale=1e-6, size=400),
+                "large": rng.normal(loc=1e6, scale=1e3, size=400),
+            }
         )
+        random.loc[::17, "normal"] = np.nan
+        cancer, cancer_y = load_breast_cancer(return_X_y=True, as_frame=True)
+        datasets = [
+            (random, (rng.random(400) < 0.4).astype(int)),  # Tree binning.
+            (random, None),  # Quantile binning.
+            (cancer, cancer_y.to_numpy()),
+        ]
+        for X, y in datasets:
+            full = StandardBinarizer(round_edges=False).fit_transform(X, y)
+            b = StandardBinarizer()
+            rounded = b.fit_transform(X, y)
+            np.testing.assert_array_equal(rounded.to_numpy(), full.to_numpy())
+            np.testing.assert_array_equal(b.transform(X).to_numpy(), full.to_numpy())
+            self.assertEqual(len(set(rounded.columns)), len(rounded.columns))
 
     # ------------------------------------------------------------------ #
     #  Mixed types

{hgp_lib-1.2.2 → hgp_lib-1.2.4}/tests/test_mutation_executor.py

@@ -169,6 +169,41 @@ class TestMutationExecutor(unittest.TestCase):
             executor.apply(rules)
         self.assertEqual(rules[0].value, 1)
 
+    def test_apply_keeps_first_mutation_when_second_is_invalid(self):
+        increment = _IncrementLiteral()
+        negate = NegateMutation()
+
+        def valid_incremented_non_negated_rule(rule: Rule):
+            return rule.value == 1 and not rule.negated
+
+        executor = MutationExecutor(
+            literal_mutations=[increment, negate],
+            operator_mutations=[_ToggleOperator()],
+            mutation_p=1.0,
+            check_valid=valid_incremented_non_negated_rule,
+            num_tries=1,
+        )
+
+        rules = [Literal(value=0)]
+
+        def apply_twice(self, rules: list[Rule]):
+            rules[0] = self._mutate(rules[0], 2)
+
+        with (
+            patch.object(MutationExecutor, "apply", new=apply_twice),
+            patch(
+                "hgp_lib.mutations.mutation_executor.random.choice",
+                side_effect=[increment, negate],
+            ),
+        ):
+            executor.apply(rules)
+
+        # The increment is valid and is therefore preserved.
+        self.assertEqual(rules[0].value, 1)
+
+        # The subsequent negation is invalid and is therefore discarded.
+        self.assertFalse(rules[0].negated)
+
     # ------------------------------------------------------------------ #
     #  _mutate — direct tests
     # ------------------------------------------------------------------ #

hgp_lib-1.2.2/src/hgp_lib/mutations/utils.py

@@ -1,3 +0,0 @@
-class MutationError(Exception):
-    # Placeholder class used to signify that a mutation could not be executed because it would violate constraints
-    pass