moeforecast 0.1.0__py3-none-any.whl

moeforecast/__init__.py

@@ -0,0 +1,57 @@
+"""
+moeforecast: Mixture-of-Experts time series forecasting.
+
+The library provides the building blocks to create a Mixture-of-Experts (MoE)
+forecaster from a single time series:
+
+1. ``prepare_series`` checks and regularizes the input series.
+2. ``SeriesAnalyzer`` and ``feature_relevance`` help choose seasonal periods,
+   lags and predictors.
+3. ``FeatureBuilder`` creates causal calendar, holiday, Fourier, lag and
+   rolling-window features.
+4. ``ProfileClusterer`` groups seasonal profiles (e.g. days, weeks) into regimes.
+5. ``RegimeClassifier`` predicts the regime of each time step from its features.
+6. ``ExpertSelector`` chooses and trains one regression model (expert) per regime.
+7. ``HardGating``, ``SoftGating`` and ``AdaptiveGating`` combine the experts.
+8. ``MoEForecaster`` ties every step together with ``fit``, ``predict`` and
+   ``forecast``.
+"""
+
+from moeforecast.analysis import SeriesAnalyzer, feature_relevance
+from moeforecast.classification import RegimeClassifier, compare_classifiers, default_classifiers
+from moeforecast.clustering import ProfileClusterer
+from moeforecast.data import DataReport, fill_gaps, prepare_series
+from moeforecast.experts import ExpertSelector, default_candidates
+from moeforecast.features import FeatureBuilder
+from moeforecast.gating import AdaptiveGating, HardGating, SoftGating
+from moeforecast.metrics import mape
+from moeforecast.model_selection import temporal_train_test_split
+from moeforecast.persistence import load, save
+from moeforecast.pipeline import MoEForecaster
+from moeforecast.tuning import default_search_spaces
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AdaptiveGating",
+    "DataReport",
+    "ExpertSelector",
+    "FeatureBuilder",
+    "HardGating",
+    "MoEForecaster",
+    "ProfileClusterer",
+    "RegimeClassifier",
+    "SeriesAnalyzer",
+    "SoftGating",
+    "compare_classifiers",
+    "default_classifiers",
+    "default_candidates",
+    "default_search_spaces",
+    "feature_relevance",
+    "fill_gaps",
+    "load",
+    "mape",
+    "prepare_series",
+    "save",
+    "temporal_train_test_split",
+]

moeforecast/_plotting.py

@@ -0,0 +1,35 @@
+"""Shared, local styling for moeforecast diagnostic plots."""
+
+from __future__ import annotations
+
+PALETTE = (
+    "#66c2a5",
+    "#fc8d62",
+    "#8da0cb",
+    "#e78ac3",
+    "#a6d854",
+    "#ffd92f",
+    "#e5c494",
+    "#b3b3b3",
+)
+
+
+def style_axis(ax, grid_axis: str = "both"):
+    """Apply the serif, light-grid style used throughout the reference notebooks."""
+    ax.set_facecolor("white")
+    ax.grid(
+        True,
+        axis=grid_axis,
+        color="#cbd5df",
+        alpha=0.55,
+        linewidth=0.65,
+    )
+    ax.set_axisbelow(True)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.spines["left"].set_color("#aab7c4")
+    ax.spines["bottom"].set_color("#aab7c4")
+    ax.tick_params(colors="#34495e")
+    ax.xaxis.label.set_fontfamily("serif")
+    ax.yaxis.label.set_fontfamily("serif")
+    ax.title.set_fontfamily("serif")

moeforecast/analysis.py

@@ -0,0 +1,267 @@
+"""
+Exploratory analysis aimed at configuring the model.
+
+``SeriesAnalyzer`` suggests seasonal periods and lags from the autocorrelation
+structure; ``feature_relevance`` ranks candidate features. Both only make
+recommendations: the user decides what goes into ``FeatureBuilder``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+import pandas as pd
+from sklearn.feature_selection import mutual_info_regression
+from sklearn.inspection import permutation_importance
+from statsmodels.tsa.stattools import acf, pacf
+
+from moeforecast._plotting import PALETTE, style_axis
+from moeforecast.data import step_of
+
+
+class SeriesAnalyzer:
+    """
+    Autocorrelation-based recommendations for seasonal periods and lags.
+
+    Parameters
+    ----------
+    max_lag : int, optional
+        Largest lag analysed. Defaults to two weeks of steps for sub-daily
+        data and 400 steps otherwise.
+    n_periods : int
+        Maximum number of seasonal periods to suggest.
+    n_lags : int
+        Maximum number of lags to suggest from the partial autocorrelation.
+    """
+
+    def __init__(self, max_lag: int | None = None, n_periods: int = 3, n_lags: int = 8):
+        self.max_lag = max_lag
+        self.n_periods = n_periods
+        self.n_lags = n_lags
+
+    def fit(self, y: pd.Series):
+        values = y.interpolate(limit_area="inside").dropna()
+        step = step_of(y.index.freqstr)
+        steps_per_day = pd.Timedelta("1D") / step
+        default = int(14 * steps_per_day) if steps_per_day > 1 else 400
+        self.max_lag_ = min(self.max_lag or default, len(values) // 3)
+        self.y_ = y
+        self.acf_ = pd.Series(acf(values, nlags=self.max_lag_, fft=True), name="acf")
+        # "ywm" (Yule-Walker with the biased autocovariance) keeps |PACF| <= 1 at long lags
+        self.pacf_ = pd.Series(
+            pacf(values, nlags=min(self.max_lag_, len(values) // 2 - 1), method="ywm"), name="pacf"
+        )
+        self.confidence_bound_ = 1.96 / np.sqrt(len(values))
+
+        # Seasonal periods: local maxima of the ACF, strongest first
+        a = self.acf_.to_numpy()
+        peaks = [k for k in range(2, len(a) - 1) if a[k] > a[k - 1] and a[k] >= a[k + 1] and a[k] > 0]
+        peaks = sorted(peaks, key=lambda k: a[k], reverse=True)
+        periods: list[int] = []
+        for k in peaks:  # skip near-duplicates and multiples of a stronger period
+            if all(abs(k - p) > 2 and k % p not in (0, 1, p - 1) for p in periods):
+                periods.append(k)
+            if len(periods) == self.n_periods:
+                break
+        self.suggested_periods_ = sorted(periods)
+
+        # Lags: strongest significant partial autocorrelations, plus each period and its neighbours
+        p = self.pacf_.iloc[1:]
+        significant = p[p.abs() > self.confidence_bound_].abs().sort_values(ascending=False)
+        lags = set(significant.index[: self.n_lags].astype(int))
+        for period in self.suggested_periods_:
+            lags.update({period - 1, period, period + 1})
+        self.suggested_lags_ = sorted(lag for lag in lags if 1 <= lag <= self.max_lag_)
+        return self
+
+    def summary(self) -> str:
+        return (
+            f"Suggested seasonal periods (steps): {self.suggested_periods_}\n"
+            f"Suggested lags (steps): {self.suggested_lags_}"
+        )
+
+    # ----------------------------------------------------------------- plotting
+    def plot_acf_pacf(self, axes=None, max_lag: int = 30):
+        """Plot at most ``max_lag`` ACF/PACF steps (30 by default)."""
+        import matplotlib.pyplot as plt
+
+        if max_lag < 1:
+            raise ValueError("max_lag must be a positive integer.")
+        if axes is None:
+            _, axes = plt.subplots(2, 1, figsize=(12, 6), sharex=True, layout="constrained")
+        for ax, series, title in (
+            (axes[0], self.acf_, "Autocorrelation (ACF)"),
+            (axes[1], self.pacf_, "Partial autocorrelation (PACF)"),
+        ):
+            visible = series.iloc[: max_lag + 1]
+            ax.axhspan(
+                -self.confidence_bound_,
+                self.confidence_bound_,
+                color=PALETTE[2],
+                alpha=0.22,
+                label="95% bound",
+            )
+            ax.vlines(visible.index, 0, visible.to_numpy(), color=PALETTE[0], linewidth=1.2)
+            ax.scatter(visible.index, visible.to_numpy(), color=PALETTE[0], s=15, zorder=3)
+            ax.axhline(0, color="#404040", linewidth=0.8)
+            ax.set_xlim(0, max_lag)
+            ax.set_ylabel("Correlation")
+            ax.set_title(title, loc="left", fontweight="bold")
+            style_axis(ax)
+        for period in self.suggested_periods_:
+            if period <= max_lag:
+                axes[0].axvline(period, color="#b85c5c", linestyle="--", linewidth=1.2)
+        axes[1].set_xlabel("Lag (steps)")
+        axes[0].set_xlabel("Lag (steps)")
+        axes[0].legend(frameon=False, loc="upper right")
+        return axes
+
+    def plot_seasonal_profiles(self, axes=None):
+        """Distribution of the series by hour of day, day of week and month."""
+        import matplotlib.pyplot as plt
+
+        y = self.y_.dropna()
+        groups = {
+            "Hour of day": (y.index.hour, [f"{h:02d}" for h in range(24)]),
+            "Day of week": (y.index.dayofweek, ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]),
+            "Month": (
+                y.index.month - 1,
+                ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+            ),
+        }
+        if pd.Timedelta("1D") / step_of(self.y_.index.freqstr) <= 1:
+            groups.pop("Hour of day")
+        if axes is None:
+            _, axes = plt.subplots(1, len(groups), figsize=(5.5 * len(groups), 4), layout="constrained")
+        for ax, (title, (key, tick_labels)) in zip(np.atleast_1d(axes), groups.items(), strict=True):
+            frame = pd.DataFrame({"y": y.to_numpy(), "g": key}, index=y.index)
+            present = sorted(frame["g"].unique())
+            box = ax.boxplot(
+                [frame.loc[frame["g"] == group, "y"].to_numpy() for group in present],
+                patch_artist=True,
+                showfliers=False,
+                medianprops={"color": "#17324d", "linewidth": 1.8},
+                whiskerprops={"color": "#566573"},
+                capprops={"color": "#566573"},
+            )
+            for i, patch in enumerate(box["boxes"]):
+                patch.set_facecolor(PALETTE[i % len(PALETTE)])
+                patch.set_alpha(0.8)
+            medians = frame.groupby("g", sort=True)["y"].median().reindex(present)
+            ax.plot(
+                range(1, len(present) + 1),
+                medians.to_numpy(),
+                color="#c44536",
+                marker="o",
+                linewidth=2,
+                markersize=4,
+                label="Group median",
+                zorder=4,
+            )
+            ax.set_xticks(range(1, len(present) + 1), [tick_labels[i] for i in present])
+            ax.set_title(title, loc="left", fontweight="bold")
+            ax.set_xlabel("")
+            ax.set_ylabel(str(y.name or "Value"))
+            style_axis(ax, grid_axis="y")
+            ax.legend(frameon=False)
+        return axes
+
+    def plot_decomposition(self, periods: Sequence[int] | None = None):
+        """Plot an MSTL decomposition as aligned, clearly labelled components.
+
+        A separate panel is drawn for each seasonal period. The plot is built
+        explicitly rather than using ``MSTL.plot()`` so component labels and
+        colors do not depend on statsmodels' internal axes ordering.
+        """
+        import matplotlib.dates as mdates
+        import matplotlib.pyplot as plt
+        from statsmodels.tsa.seasonal import MSTL
+
+        periods = list(self.suggested_periods_[:2] if periods is None else periods)
+        y = self.y_.interpolate(limit_area="inside").dropna()
+        if not periods:
+            raise ValueError("At least one seasonal period is required for decomposition.")
+        if any(not isinstance(period, (int, np.integer)) or period < 2 for period in periods):
+            raise ValueError("Seasonal periods must be integers greater than or equal to 2.")
+        if len(set(periods)) != len(periods):
+            raise ValueError("Seasonal periods must be unique.")
+        if len(y) < 2 * max(periods):
+            raise ValueError("MSTL needs at least two complete cycles of the largest seasonal period.")
+
+        result = MSTL(y, periods=periods).fit()
+        components = [("Observed", y, "#315b7d"), ("Trend", result.trend, "#d17a22")]
+        seasonal = result.seasonal
+        if isinstance(seasonal, pd.Series):
+            seasonal = seasonal.to_frame(name=str(periods[0]))
+        for index, period in enumerate(periods):
+            column = seasonal.columns[index]
+            components.append((f"Seasonal - {period} steps", seasonal[column], PALETTE[index % len(PALETTE)]))
+        components.append(("Residual", result.resid, "#a34d4d"))
+
+        fig, axes = plt.subplots(
+            len(components), 1, figsize=(13, 2.35 * len(components)), sharex=True, layout="constrained"
+        )
+        axes = np.atleast_1d(axes)
+        for ax, (label, values, color) in zip(axes, components, strict=True):
+            ax.plot(values.index, values.to_numpy(), color=color, linewidth=1.15)
+            ax.set_title(label, loc="left", fontsize=10, fontweight="bold", pad=5)
+            ax.set_ylabel(str(y.name or "Value") if label == "Observed" else "")
+            style_axis(ax, grid_axis="y")
+        locator = mdates.AutoDateLocator(minticks=4, maxticks=9)
+        axes[-1].xaxis.set_major_locator(locator)
+        axes[-1].xaxis.set_major_formatter(mdates.ConciseDateFormatter(locator))
+        axes[-1].set_xlabel("Date")
+        fig.suptitle(f"{y.name or 'Series'} - MSTL decomposition", x=0.01, ha="left", fontweight="bold")
+        return fig
+
+
+def feature_relevance(
+    X: pd.DataFrame,
+    y: pd.Series,
+    method: str = "mutual_info",
+    estimator=None,
+    test_fraction: float = 0.2,
+    random_state: int = 0,
+) -> pd.DataFrame:
+    """
+    Rank candidate features by their relevance for the target.
+
+    Parameters
+    ----------
+    method : {"mutual_info", "permutation"}
+        "mutual_info" measures non-linear dependence of each feature with the
+        target on its own. "permutation" fits ``estimator`` on the first part of
+        the data and measures the loss of R² on the last ``test_fraction`` when
+        each feature is shuffled; it accounts for redundancy between features.
+    estimator : regressor, optional
+        Model for the permutation method (default: HistGradientBoostingRegressor).
+
+    Returns
+    -------
+    DataFrame with columns ``feature`` and ``importance``, sorted descending.
+    """
+    mask = X.notna().all(axis=1).to_numpy() & y.notna().to_numpy()
+    Xv, yv = X[mask], y[mask]
+    if method == "mutual_info":
+        scores = mutual_info_regression(Xv, yv, random_state=random_state)
+        out = pd.DataFrame({"feature": X.columns, "importance": scores})
+    elif method == "permutation":
+        from sklearn.ensemble import HistGradientBoostingRegressor
+
+        split = int(len(Xv) * (1 - test_fraction))
+        model = estimator or HistGradientBoostingRegressor(random_state=random_state)
+        model.fit(Xv.iloc[:split], yv.iloc[:split])
+        result = permutation_importance(
+            model, Xv.iloc[split:], yv.iloc[split:], n_repeats=5, random_state=random_state
+        )
+        out = pd.DataFrame(
+            {
+                "feature": X.columns,
+                "importance": result.importances_mean,
+                "importance_std": result.importances_std,
+            }
+        )
+    else:
+        raise ValueError("method must be 'mutual_info' or 'permutation'")
+    return out.sort_values("importance", ascending=False, ignore_index=True)

moeforecast/classification.py

@@ -0,0 +1,227 @@
+"""Classifiers that predict the regime (cluster) of each time step from its features."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, ClassifierMixin, clone
+from sklearn.ensemble import HistGradientBoostingClassifier, RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, f1_score
+from sklearn.model_selection import cross_validate
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+from moeforecast.tuning import classification_time_series_splits, default_search_spaces, search_estimator
+
+
+def default_classifiers(
+    random_state: int = 0,
+    *,
+    exclude: Sequence[str] = (),
+    extra: Mapping[str, BaseEstimator] | None = None,
+) -> dict[str, BaseEstimator]:
+    """Return standard probability-capable classifiers with add/remove options."""
+    classifiers = {
+        "logistic": make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)),
+        "random_forest": RandomForestClassifier(
+            n_estimators=300, min_samples_leaf=5, n_jobs=-1, random_state=random_state
+        ),
+        "hist_gbm": HistGradientBoostingClassifier(random_state=random_state),
+    }
+    classifiers.update(extra or {})
+    for name in exclude:
+        classifiers.pop(name, None)
+    return classifiers
+
+
+class RegimeClassifier(ClassifierMixin, BaseEstimator):
+    """
+    Predict regime probabilities for the gating network.
+
+    Parameters
+    ----------
+    estimator : classifier, optional
+        Any scikit-learn classifier with ``predict_proba``. Defaults to
+        ``HistGradientBoostingClassifier``.
+    features : sequence of str, optional
+        Feature columns to use. Defaults to all columns.
+    """
+
+    def __init__(
+        self,
+        estimator: BaseEstimator | None = None,
+        features: Sequence[str] | None = None,
+        search: str | None = None,
+        search_space: Mapping[str, object] | None = None,
+        n_iter: int = 20,
+        n_splits: int = 3,
+        random_state: int = 0,
+    ):
+        self.estimator = estimator
+        self.features = features
+        self.search = search
+        self.search_space = search_space
+        self.n_iter = n_iter
+        self.n_splits = n_splits
+        self.random_state = random_state
+
+    def fit(self, X: pd.DataFrame, y: pd.Series):
+        base = self.estimator if self.estimator is not None else HistGradientBoostingClassifier()
+        if not hasattr(base, "predict_proba"):
+            raise TypeError("The regime classifier must implement predict_proba.")
+        if self.search not in {None, "grid", "random"}:
+            raise ValueError("search must be None, 'grid', or 'random'.")
+        self.features_ = list(self.features) if self.features is not None else list(X.columns)
+        mask = y.notna().to_numpy() & X[self.features_].notna().all(axis=1).to_numpy()
+        y_fit = y[mask].astype(int)
+        X_fit = X.loc[mask, self.features_]
+        if self.search is None:
+            self.estimator_ = clone(base).fit(X_fit, y_fit)
+            self.search_ = None
+        else:
+            name = _classifier_search_name(base)
+            space = self.search_space
+            if space is None:
+                try:
+                    space = default_search_spaces()[name]
+                except KeyError as exc:
+                    raise ValueError(
+                        f"No default search space for {type(base).__name__}; pass search_space explicitly."
+                    ) from exc
+            self.search_ = search_estimator(
+                clone(base),
+                space,
+                X_fit,
+                y_fit,
+                strategy=self.search,
+                n_splits=self.n_splits,
+                n_iter=self.n_iter,
+                scoring="f1_macro",
+                random_state=self.random_state,
+                cv=classification_time_series_splits(y_fit, self.n_splits),
+            )
+            self.estimator_ = self.search_.best_estimator_
+        self.classes_ = np.asarray(self.estimator_.classes_)
+        self.n_samples_fit_ = int(mask.sum())
+        self.class_counts_ = y_fit.value_counts().sort_index().reindex(self.classes_, fill_value=0)
+        return self
+
+    def predict_proba(self, X: pd.DataFrame) -> np.ndarray:
+        return self.estimator_.predict_proba(X[self.features_])
+
+    def predict(self, X: pd.DataFrame) -> np.ndarray:
+        return self.classes_[np.argmax(self.predict_proba(X), axis=1)]
+
+
+def compare_classifiers(
+    X: pd.DataFrame,
+    y: pd.Series,
+    candidates: Mapping[str, BaseEstimator] | None = None,
+    feature_sets: Mapping[str, Sequence[str]] | None = None,
+    n_splits: int = 5,
+    gap: int = 0,
+    candidate_mode: str = "replace",
+    search: str | None = None,
+    search_spaces: Mapping[str, Mapping[str, object]] | None = None,
+    n_iter: int = 20,
+    random_state: int = 0,
+) -> pd.DataFrame:
+    """
+    Cross-validate regime classifiers with forward-chaining (time-ordered) splits.
+
+    Folds never shuffle time, so hours of the same day or week cannot appear in
+    both the training and the validation fold.
+
+    Returns a DataFrame with mean and std of accuracy and macro F1 per
+    (feature set, classifier), sorted by macro F1. When ``search`` is enabled,
+    HPO is nested inside each outer validation fold to avoid scoring a model on
+    the same folds used to choose its hyperparameters.
+    """
+    if candidate_mode not in {"replace", "extend"}:
+        raise ValueError("candidate_mode must be 'replace' or 'extend'.")
+    if candidates is None:
+        candidates = default_classifiers()
+    elif candidate_mode == "extend":
+        candidates = {**default_classifiers(), **candidates}
+    if not candidates:
+        raise ValueError("At least one classifier candidate is required.")
+    if search not in {None, "grid", "random"}:
+        raise ValueError("search must be None, 'grid', or 'random'.")
+    spaces = default_search_spaces()
+    spaces.update(search_spaces or {})
+    feature_sets = feature_sets or {"all": list(X.columns)}
+    rows = []
+    for set_name, cols in feature_sets.items():
+        mask = y.notna().to_numpy() & X[list(cols)].notna().all(axis=1).to_numpy()
+        Xs, ys = X.loc[mask, list(cols)], y[mask].astype(int)
+        cv = classification_time_series_splits(ys, n_splits=n_splits, gap=gap)
+        for clf_name, clf in candidates.items():
+            params = []
+            if search is not None:
+                space = spaces.get(clf_name)
+                if space is None:
+                    inferred = _classifier_search_name(clf)
+                    space = spaces.get(inferred)
+                if space is None:
+                    raise ValueError(f"No search space configured for classifier '{clf_name}'.")
+                accuracy_scores, f1_scores = [], []
+                for fold, (train_idx, test_idx) in enumerate(cv):
+                    inner_splits = min(n_splits, len(train_idx) - 1)
+                    if inner_splits < 2:
+                        raise ValueError("Not enough training samples for nested classifier HPO.")
+                    inner_cv = classification_time_series_splits(ys.iloc[train_idx], n_splits=inner_splits)
+                    optimized = search_estimator(
+                        clone(clf),
+                        space,
+                        Xs.iloc[train_idx],
+                        ys.iloc[train_idx],
+                        strategy=search,
+                        n_splits=inner_splits,
+                        n_iter=n_iter,
+                        scoring="f1_macro",
+                        random_state=random_state + fold,
+                        cv=inner_cv,
+                    )
+                    prediction = optimized.best_estimator_.predict(Xs.iloc[test_idx])
+                    accuracy_scores.append(accuracy_score(ys.iloc[test_idx], prediction))
+                    f1_scores.append(f1_score(ys.iloc[test_idx], prediction, average="macro"))
+                    params.append(optimized.best_params_)
+                scores = {
+                    "test_accuracy": np.asarray(accuracy_scores),
+                    "test_f1_macro": np.asarray(f1_scores),
+                }
+            else:
+                scores = cross_validate(clone(clf), Xs, ys, cv=cv, scoring=("accuracy", "f1_macro"))
+            rows.append(
+                {
+                    "feature_set": set_name,
+                    "classifier": clf_name,
+                    "n_features": len(cols),
+                    "n_folds": len(cv),
+                    "accuracy_mean": scores["test_accuracy"].mean(),
+                    "accuracy_std": scores["test_accuracy"].std(),
+                    "f1_macro_mean": scores["test_f1_macro"].mean(),
+                    "f1_macro_std": scores["test_f1_macro"].std(),
+                    "best_params_by_fold": params,
+                }
+            )
+    return pd.DataFrame(rows).sort_values("f1_macro_mean", ascending=False, ignore_index=True)
+
+
+def _classifier_search_name(estimator: BaseEstimator) -> str:
+    """Map built-in classifier types to the public default search-space keys."""
+    if isinstance(estimator, RandomForestClassifier):
+        return "random_forest_classifier"
+    if isinstance(estimator, HistGradientBoostingClassifier):
+        return "hist_gbm_classifier"
+    if isinstance(estimator, LogisticRegression):
+        return "logistic_estimator"
+    if hasattr(estimator, "named_steps"):
+        final = list(estimator.named_steps.values())[-1]
+        if isinstance(final, LogisticRegression):
+            return "logistic"
+        return _classifier_search_name(final)
+    return ""