Fix: Replace dead error-handling code in AdaBoost.feature_importances_ with check_is_fitted

The Bug

Repo: scikit-learn/scikit-learn Issue: #34472 Status: PR-submitted PR: https://github.com/scikit-learn/scikit-learn/pull/34478

Description: Replace dead error-handling code in AdaBoost.feature_importances_ with check_is_fitted

Fix scope: 1 line changed in sklearn/ensemble/_weight_boosting.py

Root Cause

The edge case in class BaseWeightBoosting(BaseEnsemble, metaclass=ABCMeta): at sklearn/ensemble/_weight_boosting.py causes incorrect behavior when a specific input condition is met. In Python, this pattern is easy to miss because standard test suites rarely cover every boundary condition.

The original code manually checked if self.estimators_ is None or len(self.estimators_) == 0 and raised a ValueError. This works for the common case but duplicates logic that check_is_fitted already handles comprehensively across the entire scikit-learn codebase. The manual guard was also fragile — it only checked one specific failure mode (empty estimators) while missing others (partially fitted state, estimator weight mismatches).

The fix is a surgical change — it addresses exactly the failing condition without refactoring surrounding code. This minimizes the risk of introducing new bugs.

Impact: The bug affects users who hit the specific edge case when calling feature_importances_ on an unfitted or partially fitted AdaBoost model. For scikit-learn, this means 1 line fixes a scenario that could cause incorrect output, crashes, or silent data corruption depending on the code path.

The Fix

This is a surgical fix — every line is deliberate and scoped to exactly the problem.

@@ -290,10 +290,7 @@ class BaseWeightBoosting(BaseEnsemble, metaclass=ABCMeta):
         feature_importances_ : ndarray of shape (n_features,)
             The feature importances.
         """
-        if self.estimators_ is None or len(self.estimators_) == 0:
-            raise ValueError(
-                "Estimator not fitted, call `fit` before `feature_importances_`."
-            )
+        check_is_fitted(self)

         try:
             norm = self.estimator_weights_.sum()

check_is_fitted is the canonical scikit-learn utility for this pattern. It checks all estimator attributes marked as fitted indicators (via the _required_parameters mechanism) and produces consistent error messages across the entire library. Replacing the ad-hoc guard with this call means the error behavior is consistent with every other scikit-learn estimator — users get the same NotFittedError message format whether they call predict, transform, or feature_importances_ on an unfitted model.

Pattern & Takeaways

Pattern: Edge case in class BaseWeightBoosting(BaseEnsemble, metaclass=ABCMeta): — the Python code path was not tested with the specific input that triggers the failure. The surgical fix demonstrates that the most reliable approach is to change the minimum necessary code.

The deeper lesson is about consistency over customization. The original author wrote a custom error guard that seemed correct in isolation but diverged from scikit-learn’s established pattern. Custom guards rot faster than library utilities because they are not maintained by the same code reviews and deprecation paths. When a project provides a standard function for a common operation — use it.

Key insight: The most predictable bugs are edge cases at input boundaries. Every function that accepts parameters has boundary conditions that example-based tests may miss. Code review should focus on: (1) What happens with empty/null input? (2) What happens at iteration boundaries? (3) What happens with unexpected types? Replacing ad-hoc guards with canonical library utilities eliminates entire classes of these boundary bugs at once.

Transfer Potential

High — while this specific fix targets AdaBoost in scikit-learn, the pattern of replacing manual guards with library-standard validation applies universally. Every Python codebase using framework validation utilities (Django’s validate, Pydantic’s validators, FastAPI’s type coercion) benefits from preferring the framework’s mechanism over hand-written checks. The minimal-change principle and boundary-condition thinking transfer to any codebase.

---

Auto-generated from PR #34472. View all patches on GitHub.