scikit-learn · glemaitre · May 21, 2025 · Jan 31, 2025 · Jan 31, 2025 · Jan 31, 2025
diff --git a/doc/whats_new/upcoming_changes/sklearn.base/30763.enhancement.rst b/doc/whats_new/upcoming_changes/sklearn.base/30763.enhancement.rst
@@ -0,0 +1,4 @@
+- :class:`base.BaseEstimator` now has a parameter table added to the
+  estimators HTML representation that can be visualized with jupyter.
+  By :user:`Guillaume Lemaitre <glemaitre>` and
+  :user:`Dea María Léon <DeaMariaLeon>`
diff --git a/sklearn/base.py b/sklearn/base.py
@@ -16,9 +16,12 @@
 from . import __version__
 from ._config import config_context, get_config
 from .exceptions import InconsistentVersionWarning
-from .utils._estimator_html_repr import _HTMLDocumentationLinkMixin, estimator_html_repr
 from .utils._metadata_requests import _MetadataRequester, _routing_enabled
+from .utils._missing import is_scalar_nan
 from .utils._param_validation import validate_parameter_constraints
+from .utils._repr_html.base import ReprHTMLMixin, _HTMLDocumentationLinkMixin
+from .utils._repr_html.estimator import estimator_html_repr
+from .utils._repr_html.params import ParamsDict
 from .utils._set_output import _SetOutputMixin
 from .utils._tags import (
    ClassifierTags,
@@ -150,7 +153,7 @@ def _clone_parametrized(estimator, *, safe=True):
    return new_object


-class BaseEstimator(_HTMLDocumentationLinkMixin, _MetadataRequester):
+class BaseEstimator(ReprHTMLMixin, _HTMLDocumentationLinkMixin, _MetadataRequester):
    """Base class for all estimators in scikit-learn.

    Inheriting from this class provides default implementations of:
@@ -194,6 +197,8 @@ class BaseEstimator(_HTMLDocumentationLinkMixin, _MetadataRequester):
    array([3, 3, 3])
    """

+    _html_repr = estimator_html_repr
+
    @classmethod
    def _get_param_names(cls):
        """Get parameter names for the estimator"""
@@ -249,6 +254,64 @@ def get_params(self, deep=True):
            out[key] = value
        return out

+    def _get_params_html(self, deep=True):
+        """
+        Get parameters for this estimator with a specific HTML representation.
+
+        Parameters
+        ----------
+        deep : bool, default=True
+            If True, will return the parameters for this estimator and
+            contained subobjects that are estimators.
+
+        Returns
+        -------
+        params : ParamsDict
+            Parameter names mapped to their values. We return a `ParamsDict`
+            dictionary, which renders a specific HTML representation in table
+            form.
+        """
+        out = self.get_params(deep=deep)
+
+        init_func = getattr(self.__init__, "deprecated_original", self.__init__)
+        init_default_params = inspect.signature(init_func).parameters
+        init_default_params = {
+            name: param.default for name, param in init_default_params.items()
+        }
+
+        def is_non_default(param_name, param_value):
+            """Finds the parameters that have been set by the user."""
+            if param_name not in init_default_params:
+                # happens if k is part of a **kwargs
+                return True
+            if init_default_params[param_name] == inspect._empty:
+                # k has no default value
+                return True
+            # avoid calling repr on nested estimators
+            if isinstance(param_value, BaseEstimator) and type(param_value) is not type(
+                init_default_params[param_name]
+            ):
+                return True
+
+            if param_value != init_default_params[param_name] and not (
+                is_scalar_nan(init_default_params[param_name])
+                and is_scalar_nan(param_value)
+            ):
+                return True
+            return False
+
+        # reorder the parameters from `self.get_params` using the `__init__`
+        # signature
+        remaining_params = [name for name in out if name not in init_default_params]
+        ordered_out = {name: out[name] for name in init_default_params if name in out}
+        ordered_out.update({name: out[name] for name in remaining_params})
+
+        non_default_ls = tuple(
+            [name for name, value in ordered_out.items() if is_non_default(name, value)]
+        )
+
+        return ParamsDict(ordered_out, non_default=non_default_ls)
+
    def set_params(self, **params):
        """Set the parameters of this estimator.

@@ -409,36 +472,6 @@ class attribute, which is a dictionary `param_name: list of constraints`. See
            caller_name=self.__class__.__name__,
        )

-    @property
-    def _repr_html_(self):
-        """HTML representation of estimator.
-
-        This is redundant with the logic of `_repr_mimebundle_`. The latter
-        should be favored in the long term, `_repr_html_` is only
-        implemented for consumers who do not interpret `_repr_mimbundle_`.
-        """
-        if get_config()["display"] != "diagram":
-            raise AttributeError(
-                "_repr_html_ is only defined when the "
-                "'display' configuration option is set to "
-                "'diagram'"
-            )
-        return self._repr_html_inner
-
-    def _repr_html_inner(self):
-        """This function is returned by the @property `_repr_html_` to make
-        `hasattr(estimator, "_repr_html_") return `True` or `False` depending
-        on `get_config()["display"]`.
-        """
-        return estimator_html_repr(self)
-
-    def _repr_mimebundle_(self, **kwargs):
-        """Mime bundle used by jupyter kernels to display estimator"""
-        output = {"text/plain": repr(self)}
-        if get_config()["display"] == "diagram":
-            output["text/html"] = estimator_html_repr(self)
-        return output
-

 class ClassifierMixin:
    """Mixin class for all classifiers in scikit-learn.

diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py
@@ -20,10 +20,10 @@
 from ..pipeline import _fit_transform_one, _name_estimators, _transform_one
 from ..preprocessing import FunctionTransformer
 from ..utils import Bunch
-from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._indexing import _determine_key_type, _get_column_indices, _safe_indexing
 from ..utils._metadata_requests import METHODS
 from ..utils._param_validation import HasMethods, Hidden, Interval, StrOptions
+from ..utils._repr_html.estimator import _VisualBlock
 from ..utils._set_output import (
    _get_container_adapter,
    _get_output_config,

diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py
@@ -24,8 +24,8 @@
 from ..model_selection import check_cv, cross_val_predict
 from ..preprocessing import LabelEncoder
 from ..utils import Bunch
-from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._param_validation import HasMethods, StrOptions
+from ..utils._repr_html.estimator import _VisualBlock
 from ..utils.metadata_routing import (
    MetadataRouter,
    MethodMapping,

diff --git a/sklearn/ensemble/_voting.py b/sklearn/ensemble/_voting.py
@@ -24,8 +24,8 @@
 from ..exceptions import NotFittedError
 from ..preprocessing import LabelEncoder
 from ..utils import Bunch
-from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._param_validation import StrOptions
+from ..utils._repr_html.estimator import _VisualBlock
 from ..utils.metadata_routing import (
    MetadataRouter,
    MethodMapping,

diff --git a/sklearn/model_selection/_search.py b/sklearn/model_selection/_search.py
@@ -31,8 +31,8 @@
    get_scorer_names,
 )
 from ..utils import Bunch, check_random_state
-from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._param_validation import HasMethods, Interval, StrOptions
+from ..utils._repr_html.estimator import _VisualBlock
 from ..utils._tags import get_tags
 from ..utils.metadata_routing import (
    MetadataRouter,

diff --git a/sklearn/model_selection/tests/test_search.py b/sklearn/model_selection/tests/test_search.py
@@ -2662,21 +2662,21 @@ def test_search_html_repr():
    search_cv = GridSearchCV(pipeline, param_grid=param_grid, refit=False)
    with config_context(display="diagram"):
        repr_html = search_cv._repr_html_()
-        assert "<pre>DummyClassifier()</pre>" in repr_html
+        assert "<div>DummyClassifier</div>" in repr_html

    # Fitted with `refit=False` shows the original pipeline
    search_cv.fit(X, y)
    with config_context(display="diagram"):
        repr_html = search_cv._repr_html_()
-        assert "<pre>DummyClassifier()</pre>" in repr_html
+        assert "<div>DummyClassifier</div>" in repr_html

    # Fitted with `refit=True` shows the best estimator
    search_cv = GridSearchCV(pipeline, param_grid=param_grid, refit=True)
    search_cv.fit(X, y)
    with config_context(display="diagram"):
        repr_html = search_cv._repr_html_()
-        assert "<pre>DummyClassifier()</pre>" not in repr_html
-        assert "<pre>LogisticRegression()</pre>" in repr_html
+        assert "<div>DummyClassifier</div>" not in repr_html
+        assert "<div>LogisticRegression</div>" in repr_html


 # Metadata Routing Tests

diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py
@@ -16,9 +16,9 @@
 from .exceptions import NotFittedError
 from .preprocessing import FunctionTransformer
 from .utils import Bunch
-from .utils._estimator_html_repr import _VisualBlock
 from .utils._metadata_requests import METHODS
 from .utils._param_validation import HasMethods, Hidden
+from .utils._repr_html.estimator import _VisualBlock
 from .utils._set_output import (
    _get_container_adapter,
    _safe_set_output,

diff --git a/sklearn/preprocessing/_function_transformer.py b/sklearn/preprocessing/_function_transformer.py
@@ -7,8 +7,8 @@
 import numpy as np

 from ..base import BaseEstimator, TransformerMixin, _fit_context
-from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._param_validation import StrOptions
+from ..utils._repr_html.estimator import _VisualBlock
 from ..utils._set_output import (
    _get_adapter_from_container,
    _get_output_config,

diff --git a/sklearn/tests/test_base.py b/sklearn/tests/test_base.py
@@ -992,3 +992,11 @@ def predict(self, X, prop=None):
    with warnings.catch_warnings(record=True) as record:
        CustomOutlierDetector().set_predict_request(prop=True).fit_predict([[1]], [1])
        assert len(record) == 0
+
+
+def test_get_params_html():
+    """Check the behaviour of the `_get_params_html` method."""
+    est = MyEstimator(empty="test")
+
+    assert est._get_params_html() == {"l1": 0, "empty": "test"}
+    assert est._get_params_html().non_default == ("empty",)
diff --git a/sklearn/utils/__init__.py b/sklearn/utils/__init__.py
@@ -7,7 +7,6 @@
 from . import metadata_routing
 from ._bunch import Bunch
 from ._chunking import gen_batches, gen_even_slices
-from ._estimator_html_repr import estimator_html_repr

 # Make _safe_indexing importable from here for backward compat as this particular
 # helper is considered semi-private and typically very useful for third-party
@@ -20,6 +19,8 @@
    shuffle,
 )
 from ._mask import safe_mask
+from ._repr_html.base import _HTMLDocumentationLinkMixin  # noqa: F401
+from ._repr_html.estimator import estimator_html_repr
 from ._tags import (
    ClassifierTags,
    InputTags,

diff --git a/sklearn/utils/_repr_html/__init__.py b/sklearn/utils/_repr_html/__init__.py
@@ -0,0 +1,2 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		# Authors: The scikit-learn developers
		# SPDX-License-Identifier: BSD-3-Clause