AutoCarver 7.2.0__tar.gz → 7.2.2__tar.gz

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/carvers/binary_carver.py

@@ -65,7 +65,7 @@ class BinaryCarver(BaseCarver):
             config=config,
         )
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided")
@@ -73,9 +73,9 @@ class BinaryCarver(BaseCarver):
         if not ((0 in y_values) and (1 in y_values)) or len(y_values) != 2:
             raise ValueError(f"[{self.__name__}] y must be a binary Series of 0 and 1 (int or float, not object)")
 
-        return super()._prepare_data(samples)
+        return super()._prepare_samples(samples)
 
-    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.DataFrame | None]:
+    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.Series | pd.DataFrame | None]:
         """Computes crosstabs for specified features and ensures that the crosstab is ordered
         according to the known labels"""
         # checking for empty datasets (dev)

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/carvers/continuous_carver.py

@@ -63,7 +63,7 @@ class ContinuousCarver(BaseCarver):
             config=config,
         )
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided")
@@ -74,9 +74,9 @@ class ContinuousCarver(BaseCarver):
         if len(y_values) <= 2:
             raise ValueError(f"[{self.__name__}] provided y is binary, consider using BinaryCarver instead.")
 
-        return super()._prepare_data(samples)
+        return super()._prepare_samples(samples)
 
-    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.DataFrame | None]:
+    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.Series | pd.DataFrame | None]:
         """Computes y values for modalities of specified features and ensures the ordering
         according to the known labels"""
         # checking for empty datasets
@@ -98,4 +98,4 @@ def get_target_values_by_modality(X: pd.DataFrame, y: pd.Series, feature: BaseFe
 
     # reindexing to ensure the right order (labels may be None pre-fit; pandas
     # treats None as "no reindex" so the original ordering is kept)
-    return yval.reindex(feature.labels, fill_value=[])  # type: ignore[arg-type]
+    return yval.reindex(feature.labels, fill_value=[])  # type: ignore

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/carvers/multiclass_carver.py

@@ -53,7 +53,7 @@ class MulticlassCarver(BinaryCarver):
         if self.config.copy:
             print("WARNING: can't set copy=True for MulticlassCarver (no inplace DataFrame.assign).")
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         # converting target to str (y is required by Carver.fit)
         if samples.train.y is None:
@@ -93,11 +93,11 @@ class MulticlassCarver(BinaryCarver):
         samples = Samples(train=Sample(X, y), dev=Sample(X_dev, y_dev))
 
         # preparing datasets and checking for wrong values
-        samples = self._prepare_data(samples)
+        samples = self._prepare_samples(samples)
 
-        # getting distinct y classes (_prepare_data raises if y is missing)
-        assert samples.train.y is not None
-        y_classes = sorted(samples.train.y.unique().tolist())[1:]  # removing one of the classes
+        # getting distinct y classes (_prepare_samples raises if y is missing)
+        # removing one of the classes
+        y_classes = sorted(samples.train.y.unique().tolist())[1:]  # type: ignore
 
         # adding versionned features
         self.features.add_feature_versions(y_classes)
@@ -125,7 +125,12 @@ class MulticlassCarver(BinaryCarver):
                 config=replace(self.config, copy=True),
             )
 
-            binary_carver.fit_transform(samples.train.X, train_y_class, X_dev=samples.dev.X, y_dev=dev_y_class)
+            binary_carver.fit_transform(
+                samples.train.X,
+                train_y_class,
+                X_dev=samples.dev.X if samples.dev.has_X else None,
+                y_dev=dev_y_class,
+            )
 
             # filtering out dropped features whilst keeping other version tags
             kept_features = binary_carver.features.versions

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/carvers/utils/base_carver.py

@@ -5,6 +5,8 @@ for any task.
 import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field, replace
+from functools import partial
+from multiprocessing import Pool
 from typing import Self
 
 import pandas as pd
@@ -19,6 +21,8 @@ from AutoCarver.combinations import (
 from AutoCarver.discretizers import BaseDiscretizer, Discretizer, Sample
 from AutoCarver.discretizers.utils.base_discretizer import DiscretizerConfig
 from AutoCarver.features import BaseFeature, Features
+from AutoCarver.features.qualitatives import CategoricalFeature, OrdinalFeature
+from AutoCarver.features.quantitatives import QuantitativeFeature
 from AutoCarver.utils import extend_docstring, has_idisplay
 
 # trying to import extra dependencies
@@ -37,16 +41,63 @@ class Samples:
         dev (Sample): The development sample, containing features (X) and target (y).
     """
 
-    train: Sample = field(default_factory=lambda: Sample(X=None))
-    dev: Sample = field(default_factory=lambda: Sample(X=None))
+    train: Sample = field(default_factory=Sample)
+    dev: Sample = field(default_factory=Sample)
 
     def fillna(self, features: Features) -> None:
         """fills up nans in X and X_dev"""
         self.train.X = features.fillna(self.train.X)
-        if self.dev.X is not None:
+        if self.dev.has_X:
             self.dev.X = features.fillna(self.dev.X)
 
 
+def _carve_feature_worker(
+    payload: tuple[BaseFeature, pd.Series | pd.DataFrame | None, pd.Series | pd.DataFrame | None],
+    *,
+    evaluator: CombinationEvaluator,
+    max_n_mod: int,
+    min_freq: float,
+    dropna: bool,
+) -> tuple[BaseFeature, bool]:
+    """Picklable worker: scores best combination for a single feature.
+
+    Each pool task receives a pickled deep copy of ``evaluator`` and a single
+    ``(feature, xagg, xagg_dev)`` triple; mutations stay local to the worker
+    process. The parent reattaches the returned (mutated) feature to its
+    ``Features`` container.
+    """
+    feature, xagg, xagg_dev = payload
+    # workers never print per-feature progress; the parent prints a single banner
+    evaluator.verbose = False
+    best = evaluator.get_best_combination(
+        feature, xagg, xagg_dev, max_n_mod=max_n_mod, min_freq=min_freq, dropna=dropna
+    )
+    return feature, best is not None
+
+
+def _replace_feature_in_features(features: Features, updated: BaseFeature) -> None:
+    """Swaps an existing feature (by version) for the worker-returned copy."""
+    if isinstance(updated, CategoricalFeature):
+        categoricals = features.categoricals
+        for i, existing in enumerate(categoricals):
+            if existing.version == updated.version:
+                categoricals[i] = updated
+                return
+    elif isinstance(updated, OrdinalFeature):
+        ordinals = features.ordinals
+        for i, existing in enumerate(ordinals):
+            if existing.version == updated.version:
+                ordinals[i] = updated
+                return
+    elif isinstance(updated, QuantitativeFeature):
+        quantitatives = features.quantitatives
+        for i, existing in enumerate(quantitatives):
+            if existing.version == updated.version:
+                quantitatives[i] = updated
+                return
+    raise KeyError(f"[BaseCarver] feature {updated.version!r} not in Features")
+
+
 class BaseCarver(BaseDiscretizer, ABC):
     """Automatic carving of continuous, discrete, categorical and ordinal
     features that maximizes association with a binary or continuous target.
@@ -124,14 +175,14 @@ class BaseCarver(BaseDiscretizer, ABC):
         content["combination_evaluator"] = self.combination_evaluator.to_json()
         return content
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided, got {samples.train.y}")
 
         # Checking for binary target and copying X
-        samples.train = super()._prepare_data(samples.train)
-        samples.dev = super()._prepare_data(samples.dev)
+        samples.train = super()._prepare_sample(samples.train)
+        samples.dev = super()._prepare_sample(samples.dev)
 
         # discretizing features at half min_freq so the carver has a finer
         # granularity to combine when forming optimal groups
@@ -145,7 +196,7 @@ class BaseCarver(BaseDiscretizer, ABC):
 
         return samples
 
-    def fit(  # pylint: disable=W0222
+    def fit(  # type: ignore
         self,
         X: pd.DataFrame,
         y: pd.Series,
@@ -184,7 +235,7 @@ class BaseCarver(BaseDiscretizer, ABC):
         samples = Samples(Sample(X, y), Sample(X_dev, y_dev))
 
         # preparing datasets and checking for wrong values
-        samples = self._prepare_data(samples)
+        samples = self._prepare_samples(samples)
 
         # logging if requested
         super()._log_if_verbose("---------\n------")
@@ -196,16 +247,55 @@ class BaseCarver(BaseDiscretizer, ABC):
         # getting all features to carve (features are removed from self.features)
         all_features = self.features.versions
 
-        # carving each feature
-        for n, feature in enumerate(all_features):
-            num_iter = f"{n + 1}/{len(all_features)}"  # logging iteration number
-            self._carve_feature(self.features(feature), xaggs, xaggs_dev, num_iter)
+        # carving each feature (parallel across features when n_jobs > 1)
+        if self.config.n_jobs > 1 and len(all_features) > 1:
+            self._carve_features_parallel(all_features, xaggs, xaggs_dev)
+        else:
+            for n, feature in enumerate(all_features):
+                num_iter = f"{n + 1}/{len(all_features)}"  # logging iteration number
+                self._carve_feature(self.features(feature), xaggs, xaggs_dev, num_iter)
 
         # discretizing features based on each feature's values_order
         super().fit(X, y)
 
         return self
 
+    def _carve_features_parallel(
+        self,
+        all_features: list[str],
+        xaggs: dict[str, pd.Series | pd.DataFrame | None],
+        xaggs_dev: dict[str, pd.Series | pd.DataFrame | None],
+    ) -> None:
+        """Dispatches ``_carve_feature`` across a process pool, one task per feature.
+
+        Per-feature workers receive only the feature instance + its xagg /
+        xagg_dev slice (not the full dict). Verbose per-feature logging is
+        silenced; a single banner is printed when verbose is on.
+        """
+        if self.config.verbose:
+            print(f"--- [{self.__name__}] Carving {len(all_features)} features on {self.config.n_jobs} workers")
+
+        payloads = [(self.features(version), xaggs[version], xaggs_dev[version]) for version in all_features]
+        worker = partial(
+            _carve_feature_worker,
+            evaluator=self.combination_evaluator,
+            max_n_mod=self.max_n_mod,
+            min_freq=self.min_freq,
+            dropna=self.config.dropna,
+        )
+
+        with Pool(processes=self.config.n_jobs) as pool:
+            for updated_feature, viable in pool.imap_unordered(worker, payloads):
+                if viable:
+                    _replace_feature_in_features(self.features, updated_feature)
+                else:
+                    print(
+                        f"WARNING: No robust combination for {updated_feature}. Consider "
+                        "increasing the size of X_dev or dropping the feature (X not "
+                        "representative of X_dev for this feature)."
+                    )
+                    self.features.remove(updated_feature.version)
+
     @abstractmethod
     def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.Series | pd.DataFrame | None]:
         """Helper that aggregates X by y into per-feature crosstabs or means
@@ -239,10 +329,11 @@ class BaseCarver(BaseDiscretizer, ABC):
 
         # printing carved distribution, for found, suitable combination
         if best_combination is not None:
+            dev_sample = self.combination_evaluator.samples.dev
             self._print_xagg(
                 feature,
                 xagg=self.combination_evaluator.samples.train.xagg,
-                xagg_dev=self.combination_evaluator.samples.dev.xagg,
+                xagg_dev=dev_sample.xagg if dev_sample.has_xagg else None,
                 message="Carved distribution",
             )
 
@@ -392,7 +483,7 @@ def discretize(
     samples.train.X = discretizer.fit_transform(**samples.train)
 
     # applying discretizer on X_dev if provided
-    if samples.dev.X is not None:
+    if samples.dev.has_X:
         samples.dev.X = discretizer.transform(**samples.dev)
 
     return samples

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/carvers/utils/pretty_print.py

@@ -44,14 +44,14 @@ def prettier_xagg(
 
         # adding custom caption/title
         if caption is not None:
-            nicer_xagg = nicer_xagg.set_caption(caption)
+            nicer_xagg = nicer_xagg.set_caption(caption)  # type: ignore
 
         # hiding index for dev
         if hide_index:
-            nicer_xagg.hide(axis="index")
+            nicer_xagg.hide(axis="index")  # type: ignore
 
         # converting to html
-        nicer_xagg = nicer_xagg._repr_html_()  # pylint: disable=W0212
+        nicer_xagg = nicer_xagg._repr_html_()  # type: ignore
 
     return nicer_xagg
 

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/combinations/binary/binary_combination_evaluators.py

@@ -14,15 +14,19 @@ from AutoCarver.combinations.utils.combination_evaluator import (
     CombinationEvaluator,
 )
 from AutoCarver.combinations.utils.combinations import combination_formatter
+from AutoCarver.combinations.utils.target_rate import TargetRate
 
 
-class BinaryCombinationEvaluator(CombinationEvaluator, ABC):
+class BinaryCombinationEvaluator(CombinationEvaluator[pd.DataFrame], ABC):
     """Binary combination evaluator class."""
 
     is_y_binary = True
     _target_rate_classes: list[type[BinaryTargetRate]] = [TargetMean, OddsRatio, Woe]
+    # narrow inherited attribute: binary evaluators always carry a BinaryTargetRate
+    # (enforced by _init_target_rate).
+    target_rate: BinaryTargetRate
 
-    def _init_target_rate(self, target_rate: BinaryTargetRate | None) -> BinaryTargetRate:
+    def _init_target_rate(self, target_rate: TargetRate[pd.DataFrame] | None) -> BinaryTargetRate:
         """Initializes target rate."""
         if target_rate is None:
             return TargetMean()
@@ -31,8 +35,11 @@ class BinaryCombinationEvaluator(CombinationEvaluator, ABC):
         return target_rate
 
     def _association_measure(
-        self, xagg: AggregatedSample, n_obs: int | None = None, tol: float = 1e-10
-    ) -> dict[str, float]:
+        self,
+        xagg: AggregatedSample | pd.Series | pd.DataFrame,
+        n_obs: int | None = None,
+        tol: float = 1e-10,
+    ) -> dict[str, float | None]:
         """Computes measures of association between feature and target by crosstab.
 
         Used for the raw (one-shot) distribution. The hot per-combination loop

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/combinations/binary/binary_target_rates.py

@@ -1,6 +1,7 @@
 """set of target rates for binary classification"""
 
 from abc import ABC
+from typing import overload
 
 import numpy as np
 import pandas as pd
@@ -8,12 +9,16 @@ import pandas as pd
 from AutoCarver.combinations.utils import TargetRate
 
 
-class BinaryTargetRate(TargetRate, ABC):
+class BinaryTargetRate(TargetRate[pd.DataFrame], ABC):
     """Binary target rate class."""
 
     __name__ = "binary_target_rate"
 
-    def compute(self, xagg: pd.DataFrame) -> pd.DataFrame:
+    @overload
+    def compute(self, xagg: pd.Series | pd.DataFrame) -> pd.DataFrame: ...
+    @overload
+    def compute(self, xagg: None) -> None: ...
+    def compute(self, xagg: pd.Series | pd.DataFrame | None) -> pd.DataFrame | None:
         """Computes the target rate.
 
         Parameters
@@ -31,8 +36,12 @@ class BinaryTargetRate(TargetRate, ABC):
             # frequency per modality
             frequency = xagg.sum(axis=1) / xagg.sum().sum()
 
-            # computing target rate
-            return pd.DataFrame({self.__name__: self._compute(xagg), "frequency": frequency})
+            # computing target rate. `_compute` expects pd.DataFrame (Generic
+            # XAgg=DataFrame); compute()'s wide signature is for LSP matching,
+            # callers always pass a crosstab here.
+            return pd.DataFrame(
+                {self.__name__: self._compute(xagg), "frequency": frequency}  # type: ignore
+            )
         return None
 
 

{autocarver-7.2.0 → autocarver-7.2.2}/AutoCarver/combinations/continuous/continuous_combination_evaluators.py

@@ -2,6 +2,7 @@
 
 from abc import ABC
 from collections.abc import Iterable, Iterator
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -11,15 +12,20 @@ from tqdm import tqdm
 from AutoCarver.combinations.continuous.continuous_target_rates import ContinuousTargetRate, TargetMean, TargetMedian
 from AutoCarver.combinations.utils.combination_evaluator import AggregatedSample, CombinationEvaluator
 from AutoCarver.combinations.utils.combinations import combination_formatter
+from AutoCarver.combinations.utils.target_rate import TargetRate
+from AutoCarver.combinations.utils.testing import Keys, is_viable, test_viability
 
 
-class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
+class ContinuousCombinationEvaluator(CombinationEvaluator[pd.Series], ABC):
     """Continuous combination evaluator class."""
 
     is_y_continuous = True
     _target_rate_classes: list[type[ContinuousTargetRate]] = [TargetMean, TargetMedian]
+    # narrow the inherited `target_rate: TargetRate` annotation — continuous
+    # carvers always carry a ContinuousTargetRate (enforced by _init_target_rate).
+    target_rate: ContinuousTargetRate
 
-    def _init_target_rate(self, target_rate: ContinuousTargetRate | None) -> ContinuousTargetRate:
+    def _init_target_rate(self, target_rate: TargetRate[pd.Series] | None) -> ContinuousTargetRate:
         """Initializes target rate."""
         if target_rate is None:
             return TargetMean()
@@ -28,7 +34,10 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
         return target_rate
 
     def _association_measure(
-        self, xagg: AggregatedSample, n_obs: int | None = None, tol: float = 1e-10
+        self,
+        xagg: AggregatedSample | pd.Series | pd.DataFrame,
+        n_obs: int | None = None,
+        tol: float = 1e-10,
     ) -> dict[str, float | None]:
         """Computes measures of association between feature and quantitative target.
 
@@ -134,13 +143,29 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
           :meth:`_association_measure`).
         """
         raw_xagg = self.samples.train.xagg
-        # Pre-rank y once for the whole feature
-        R_per_mod, n_per_mod, N, tie_corr = _modality_rank_stats(raw_xagg)
+        # Pre-rank y once for the whole feature.
+        R_per_mod, n_per_mod, N, tie_corr = _modality_rank_stats(raw_xagg)  # type: ignore
 
         # Map modality label -> position in R_per_mod / n_per_mod
         mod_to_pos: dict = {m: i for i, m in enumerate(raw_xagg.index)}
         n_mod = len(mod_to_pos)
 
+        # Cache per-modality (n, sum_y) for the viability fast path.
+        # Resets each time _compute_associations runs so the nan-pass refreshes
+        # the cache after _apply_best_combination changes samples.train.xagg.
+        sum_y_per_mod = _modality_sum_y(raw_xagg)  # type: ignore
+        # Why: heterogeneous-value dict; annotate `Any` so downstream readers (line 203-204
+        # and _get_dev_modality_stats) can narrow to the per-key concrete type without ty
+        # unioning across all value types.
+        self._train_modality_stats: dict[str, Any] = {
+            "n_per_mod": n_per_mod.astype(float),
+            "sum_y_per_mod": sum_y_per_mod,
+            "mod_to_pos": mod_to_pos,
+            "n_mod": n_mod,
+        }
+        self._dev_modality_stats: dict[str, Any] | None = None  # lazy; aligned to train's mod_to_pos
+        self._dev_modality_stats_id: int | None = None
+
         batch: list[dict] = []
         for grouped_xagg in tqdm(grouped_xaggs, desc="Computing associations", disable=not self.verbose):
             batch.append(grouped_xagg)
@@ -166,6 +191,100 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
                 n_mod=n_mod,
             )
 
+    def _get_dev_modality_stats(self) -> dict | None:
+        """Lazily build per-modality ``(n, sum_y)`` for the dev sample,
+        aligned to ``self._train_modality_stats['mod_to_pos']`` (zeros for
+        modalities absent from dev). Returns ``None`` when no dev sample is set.
+
+        Cache is keyed by ``id(dev_xagg)`` so external reassignment of
+        ``samples.dev`` between viability iterations triggers a fresh
+        computation (the unit tests rely on this; production flows reassign
+        dev only via ``samples.set`` at the start of ``get_best_combination``).
+        """
+        if not self.samples.dev.has_xagg:
+            return None
+        dev_xagg = self.samples.dev.xagg
+        if self._dev_modality_stats is not None and self._dev_modality_stats_id == id(dev_xagg):
+            return self._dev_modality_stats
+        train_stats = self._train_modality_stats
+        mod_to_pos: dict = train_stats["mod_to_pos"]
+        n_mod: int = train_stats["n_mod"]
+
+        n = np.zeros(n_mod, dtype=float)
+        sum_y = np.zeros(n_mod, dtype=float)
+        for mod, vals in dev_xagg.items():
+            pos = mod_to_pos.get(mod)
+            if pos is None:
+                continue  # dev has a modality train doesn't — skip
+            arr = np.asarray(vals, dtype=float)
+            n[pos] = arr.size
+            sum_y[pos] = float(arr.sum())
+
+        self._dev_modality_stats = {
+            "n_per_mod": n,
+            "sum_y_per_mod": sum_y,
+            "mod_to_pos": mod_to_pos,
+            "n_mod": n_mod,
+        }
+        self._dev_modality_stats_id = id(dev_xagg)
+        return self._dev_modality_stats
+
+    def _test_viability_train(self, combination: dict) -> dict:
+        """Fast-path viability on train; falls back to legacy when the active
+        target rate's ``compute_from_stats`` returns ``None`` (e.g.
+        ``TargetMedian`` whose default closed-form path is a no-op).
+        """
+        stats = getattr(self, "_train_modality_stats", None)
+        if stats is not None:
+            train_rates = self.target_rate.compute_from_stats(
+                stats=stats, index_to_groupby=combination["index_to_groupby"]
+            )
+            if train_rates is not None:
+                return test_viability(train_rates, self.min_freq, self.target_rate.__name__)
+        # Fallback: legacy grouper + apply(np.mean/median) over Python lists
+        return super()._test_viability_train(combination)
+
+    def _get_viable_combination(self, associations: list[dict]) -> dict | None:
+        """Walks associations under the fast viability path and materialises
+        the winning combination's grouped xagg once at the end.
+
+        The fast path skips ``combination['xagg']`` because the closed-form
+        viability check doesn't need it; downstream consumers (debug, tests,
+        and any future code that introspects the winner) still expect to see
+        it, so we rebuild it for the winner only — that's one ``_grouper``
+        call per feature instead of ~13k per feature.
+        """
+        viable = super()._get_viable_combination(associations)
+        if viable is not None and viable.get("xagg") is None:
+            # `clean_combination` pops `index_to_groupby` during historization
+            # earlier in the loop, so rebuild it from the still-present
+            # `combination` list-of-groups.
+            index_to_groupby = viable.get("index_to_groupby")
+            if index_to_groupby is None:
+                index_to_groupby = combination_formatter(viable["combination"])
+            viable["xagg"] = self._grouper(self.samples.train, index_to_groupby)
+        return viable
+
+    def _test_viability_dev(self, test_results: dict, combination: dict) -> dict:
+        """Fast-path viability on dev; falls back to legacy when the active
+        target rate's ``compute_from_stats`` returns ``None``.
+        """
+        if not test_results[Keys.VIABLE.value] or not self.samples.dev.has_xagg:
+            return {**test_results, "dev": {Keys.VIABLE.value: None}}
+
+        dev_stats = self._get_dev_modality_stats()
+        if dev_stats is not None:
+            dev_rates = self.target_rate.compute_from_stats(
+                stats=dev_stats, index_to_groupby=combination["index_to_groupby"]
+            )
+            if dev_rates is not None:
+                train_target_rate = test_results["train_rates"][self.target_rate.__name__]
+                dev_results = test_viability(dev_rates, self.min_freq, self.target_rate.__name__, train_target_rate)
+                merged = {**test_results, **dev_results}
+                merged[Keys.VIABLE.value] = is_viable(merged)
+                return merged
+        return super()._test_viability_dev(test_results, combination)
+
 
 class KruskalCombinations(ContinuousCombinationEvaluator):
     """Kruskal-Wallis' H based combination evaluation toolkit"""
@@ -186,6 +305,18 @@ _KRUSKAL_BATCH_SIZE = 1024
 # ---------------------------------------------------------------------------
 
 
+def _modality_sum_y(raw_xagg: pd.Series) -> np.ndarray:
+    """Per-modality ``sum_y`` aligned with ``raw_xagg.index``.
+
+    Used by the viability fast path (Step 3.5) to compute group target means
+    in closed form (``sum_y_g / n_g``) instead of applying ``np.mean`` to
+    Python lists of y values per candidate.
+    """
+    return np.fromiter(
+        (float(np.asarray(v, dtype=float).sum()) for v in raw_xagg.values), dtype=float, count=len(raw_xagg)
+    )
+
+
 def _modality_rank_stats(
     raw_xagg: pd.Series,
 ) -> tuple[np.ndarray | None, np.ndarray, int, float | None]: