refactor: Rename EstimatorReport._estimator to EstimatorReport.learner_

Previously we had `estimator`, `estimator_` and `_estimator`.

Author: auguste-probabl

skore/src/skore/_plugins/hub/artifact/media/model.py

@@ -13,8 +13,10 @@ class EstimatorHtmlRepr(Media[Report]):  # noqa: D101
     def content_to_upload(self) -> str:  # noqa: D102
         import sklearn.utils
 
+        # FIXME: Unclear if we want to repr of estimator_
+        # or the original_estimator
         estimator_html_repr: str = sklearn.utils.estimator_html_repr(
-            self.report.estimator
+            self.report.estimator_
         )
 
         return estimator_html_repr

skore/src/skore/_sklearn/_checks/model_checks.py

@@ -290,7 +290,7 @@ def check_function(self, report: _BaseReport) -> str | None:
             isinstance(report, EstimatorReport)
             and report.X_train is not None
             and report.X_test is not None
-            and hasattr(report.estimator, "coef_")
+            and hasattr(report.estimator_, "coef_")
         ):
             raise CheckNotApplicable()
 

skore/src/skore/_sklearn/_comparison/metrics_accessor.py

@@ -1182,10 +1182,10 @@ def confusion_matrix(
         """
         do_thresholds = True
         if not all(
-            hasattr(report._estimator, "predict_proba")
+            hasattr(report.learner_, "predict_proba")
             for report in self._parent.reports_.values()
         ) and not all(
-            hasattr(report._estimator, "decision_function")
+            hasattr(report.learner_, "decision_function")
             for report in self._parent.reports_.values()
         ):
             warnings.warn(

skore/src/skore/_sklearn/_comparison/report.py

@@ -523,7 +523,7 @@ def create_estimator_report(
             X_train, y_train = estimator_report.X_train, estimator_report.y_train
 
         return EstimatorReport(
-            estimator_report._raw_estimator,
+            estimator_report._original_estimator,
             fit=True,
             X_train=X_train,
             y_train=y_train,

skore/src/skore/_sklearn/_cross_validation/report.py

@@ -9,7 +9,7 @@
 import skrub
 from joblib import Parallel
 from numpy.typing import ArrayLike
-from sklearn.base import BaseEstimator, clone, is_classifier
+from sklearn.base import clone, is_classifier
 from sklearn.model_selection import check_cv
 from sklearn.pipeline import Pipeline
 
@@ -66,7 +66,7 @@ def _check_estimator_and_data(
     X: ArrayLike | None,
     y: ArrayLike | None,
     data: dict | None,
-) -> tuple[bool, EstimatorLike, dict]:
+) -> tuple[bool, skrub.SkrubLearner, dict]:
     if is_skrub_learner(estimator):
         initialized_with_data_op = True
         if X is not None or y is not None:
@@ -153,7 +153,13 @@ class CrossValidationReport(_BaseReport, DirNamesMixin):
     Attributes
     ----------
     estimator_ : estimator object
-        The cloned or copied estimator.
+        The fitted estimator.
+
+    estimator : estimator object
+        The estimator that was given as input.
+
+    learner_ : skrub.SkrubLearner
+        The estimator wrapped in a skrub Learner.
 
     estimator_name_ : str
         The name of the estimator.
@@ -204,7 +210,7 @@ def __init__(
         n_jobs: int | None = None,
     ) -> None:
         super().__init__()
-        self._raw_estimator = estimator
+        self._original_estimator = estimator
         if isinstance(estimator, skrub.DataOp):
             if data is None:
                 data = estimator.skb.get_data()
@@ -214,7 +220,7 @@ def __init__(
                 "Clustering models are not supported yet. Please use a"
                 " classification or regression model instead."
             )
-        self._initialized_with_data_op, self._estimator, self._data = (
+        self._initialized_with_data_op, self.learner_, self._data = (
             _check_estimator_and_data(clone(estimator), X, y, data)
         )
         self._pos_label = pos_label
@@ -244,12 +250,12 @@ def _fit_estimator_reports(self) -> list[EstimatorReport]:
                 track(
                     parallel(
                         delayed(EstimatorReport)(
-                            clone(self._estimator),
+                            clone(self.learner_),
                             train_data=split["train"],
                             test_data=split["test"],
                             pos_label=self._pos_label,
                         )
-                        for split in self._estimator.data_op.skb.iter_cv_splits(
+                        for split in self.learner_.data_op.skb.iter_cv_splits(
                             environment=self._data, cv=self.split_indices
                         )
                     ),
@@ -264,7 +270,7 @@ def _fit_estimator_reports(self) -> list[EstimatorReport]:
                 track(
                     parallel(
                         delayed(_generate_estimator_report)(
-                            clone(self._raw_estimator),
+                            clone(self._original_estimator),
                             self.X,
                             self.y,
                             self.pos_label,
@@ -296,10 +302,10 @@ def get_state(self) -> dict[str, Any]:
             "version": _STATE_VERSION,
             "metadata": self._metadata,
             "initialized_with_data_op": self._initialized_with_data_op,
-            "raw_estimator": self._raw_estimator,
+            "original_estimator": self._original_estimator,
             "ml_task": self.ml_task,
             "pos_label": self.pos_label,
-            "estimator": self._estimator,
+            "estimator": self.learner_,
             "data": self._data,
             "split_indices": self._split_indices,
             "estimator_reports": sub_states,
@@ -323,8 +329,8 @@ def from_state(cls, state: dict[str, Any]) -> CrossValidationReport:
         report._initialized_with_data_op = state["initialized_with_data_op"]
         report._ml_task = state["ml_task"]
         report._pos_label = state["pos_label"]
-        report._estimator = state["estimator"]
-        report._raw_estimator = state["raw_estimator"]
+        report.learner_ = state["estimator"]
+        report._original_estimator = state["original_estimator"]
         report._data = state["data"]
         report._split_indices = state["split_indices"]
         # TODO? Include splitter in state?
@@ -333,7 +339,7 @@ def from_state(cls, state: dict[str, Any]) -> CrossValidationReport:
 
         report.estimator_reports_ = []
         if report._initialized_with_data_op:
-            split_data_iterator = report._estimator.data_op.skb.iter_cv_splits(
+            split_data_iterator = report.learner_.data_op.skb.iter_cv_splits(
                 environment=report._data,
                 cv=report._split_indices,
             )
@@ -535,14 +541,14 @@ def create_estimator_report(
         """
         if self._initialized_with_data_op:
             report = EstimatorReport(
-                self._estimator,
+                self.learner_,
                 train_data=self._data,
                 test_data=test_data,
                 pos_label=self._pos_label,
             )
         else:
             report = EstimatorReport(
-                self._raw_estimator,
+                self._original_estimator,
                 X_train=self.X,
                 y_train=self.y,
                 X_test=X_test,
@@ -586,21 +592,23 @@ def ml_task(self) -> str:
         return self._ml_task
 
     @property
-    def estimator(self) -> BaseEstimator:
-        return self.estimator_
+    def original_estimator(self) -> EstimatorLike:
+        """The estimator that was given as input."""
+        return self._original_estimator
 
     @property
-    def estimator_(self) -> BaseEstimator:
+    def estimator_(self) -> EstimatorLike:
+        """The report's fitted estimator."""
         if self._initialized_with_data_op:
-            return self._estimator
-        return to_estimator(self._estimator)
+            return self.learner_
+        return to_estimator(self.learner_)
 
     @property
     def estimator_name_(self) -> str:
-        if isinstance(self._raw_estimator, Pipeline):
-            name = self._raw_estimator[-1].__class__.__name__
+        if isinstance(self._original_estimator, Pipeline):
+            name = self._original_estimator[-1].__class__.__name__
         else:
-            name = self._raw_estimator.__class__.__name__
+            name = self._original_estimator.__class__.__name__
         return name
 
     @property

skore/src/skore/_sklearn/_estimator/metrics_accessor.py

@@ -1163,8 +1163,8 @@ def confusion_matrix(
                 "data_source='both' is not supported for confusion_matrix."
             )
 
-        if hasattr(self._parent._estimator, "predict_proba") or hasattr(
-            self._parent._estimator, "decision_function"
+        if hasattr(self._parent.learner_, "predict_proba") or hasattr(
+            self._parent.learner_, "decision_function"
         ):
             y_scores = self._parent._get_predictions(
                 data_source=data_source,

skore/src/skore/_sklearn/_estimator/report.py

@@ -11,7 +11,7 @@
 import numpy as np
 import skrub
 from numpy.typing import ArrayLike
-from sklearn.base import BaseEstimator, clone
+from sklearn.base import clone
 from sklearn.exceptions import NotFittedError
 from sklearn.pipeline import Pipeline
 from sklearn.utils._response import (
@@ -52,7 +52,7 @@ def _check_estimator_and_data(
     y_test: ArrayLike | None,
     train_data: dict | None,
     test_data: dict | None,
-) -> tuple[bool, EstimatorLike, dict | None, dict | None]:
+) -> tuple[bool, skrub.SkrubLearner, dict | None, dict | None]:
     """Check and validate the estimator and data."""
     if is_skrub_learner(estimator):
         initialized_with_data_op = True
@@ -140,7 +140,13 @@ class EstimatorReport(_BaseReport, DirNamesMixin):
     Attributes
     ----------
     estimator_ : estimator object
-        The cloned or copied estimator.
+        The fitted estimator.
+
+    original_estimator : estimator object
+        The estimator that was given as input.
+
+    learner_ : skrub.SkrubLearner
+        The estimator wrapped in a skrub Learner.
 
     estimator_name_ : str
         The name of the estimator.
@@ -230,7 +236,7 @@ def __init__(
     ) -> None:
         super().__init__()
         estimator = self._copy_estimator(estimator)
-        self._raw_estimator = estimator
+        self._original_estimator = estimator
         self._fit = fit
 
         if isinstance(estimator, skrub.DataOp):
@@ -254,17 +260,17 @@ def __init__(
         if fit == "auto":
             try:
                 check_is_fitted(estimator)
-                self._estimator = estimator
+                self.learner_ = estimator
             except NotFittedError:
-                self._estimator, self._fit_time = self._fit_estimator(
+                self.learner_, self._fit_time = self._fit_estimator(
                     estimator, self._train_data
                 )
         elif fit is True:
-            self._estimator, self._fit_time = self._fit_estimator(
+            self.learner_, self._fit_time = self._fit_estimator(
                 estimator, self._train_data
             )
         else:  # fit is False
-            self._estimator = estimator
+            self.learner_ = estimator
 
         self._pos_label = pos_label
         self.fit_time_ = self._fit_time
@@ -320,12 +326,12 @@ def get_state(self) -> dict[str, Any]:
             # -------- CORE STATE ---------
             "metadata": self._metadata,
             "initialized_with_data_op": self._initialized_with_data_op,
-            "raw_estimator": self._raw_estimator,
+            "original_estimator": self._original_estimator,
             "ml_task": self._ml_task,
             "fit": self._fit,
             "fit_time": self.fit_time_,
             "pos_label": self._pos_label,
-            "estimator": self._estimator,
+            "estimator": self.learner_,
             "data": {
                 "train_data": self._train_data,
                 "test_data": self._test_data,
@@ -360,8 +366,8 @@ def from_state(cls, state: dict[str, Any]) -> EstimatorReport:
         report._fit = state["fit"]
         report.fit_time_ = state["fit_time"]
         report._pos_label = state["pos_label"]
-        report._estimator = state["estimator"]
-        report._raw_estimator = state["raw_estimator"]
+        report.learner_ = state["estimator"]
+        report._original_estimator = state["original_estimator"]
         data = state["data"]
         report._train_data = data["train_data"]
         report._test_data = data["test_data"]
@@ -451,11 +457,11 @@ def cache_predictions(
         # from decision_function/predict_proba:
         if not self._can_skip_predict:
             with MeasureTime() as pred_time:
-                self._cache[pred_key] = self._estimator.predict(data)
+                self._cache[pred_key] = self.learner_.predict(data)
             self._cache[time_key] = pred_time()
 
-        has_proba = hasattr(self._estimator, "predict_proba")
-        has_decision = hasattr(self._estimator, "decision_function")
+        has_proba = hasattr(self.learner_, "predict_proba")
+        has_decision = hasattr(self.learner_, "decision_function")
 
         if not (has_proba or has_decision):
             return
@@ -517,8 +523,8 @@ def _get_response_and_derived_predictions(
             Time spent computing ``response_method(data)`` in seconds.
         """
         with MeasureTime() as pred_time:
-            response = getattr(self._estimator, response_method)(data)
-        classes = self._estimator.classes_
+            response = getattr(self.learner_, response_method)(data)
+        classes = self.learner_.classes_
         if response_method == "decision_function":
             if self.ml_task == "binary-classification":
                 response = np.vstack((-response, response)).T
@@ -538,7 +544,7 @@ def _can_skip_predict(self) -> bool:
         """
         response_methods = ["decision_function", "predict_proba"]
         try:
-            method = _check_response_method(self._estimator, response_methods)
+            method = _check_response_method(self.learner_, response_methods)
         except AttributeError:
             return False
         data = self.train_data if self.test_data is None else self.test_data
@@ -557,7 +563,7 @@ def _can_skip_predict(self) -> bool:
             sampled_data = data | {"_skrub_X": X_sample}
 
         # probe:
-        predictions = self._estimator.predict(sampled_data)
+        predictions = self.learner_.predict(sampled_data)
         _, deduced_predictions, _ = self._get_response_and_derived_predictions(
             sampled_data,
             response_method=method.__name__,
@@ -727,14 +733,16 @@ def ml_task(self):
         return self._ml_task
 
     @property
-    def estimator(self) -> BaseEstimator:
-        return self.estimator_
+    def original_estimator(self) -> EstimatorLike:
+        """The estimator that was given as input."""
+        return self._original_estimator
 
     @property
-    def estimator_(self) -> BaseEstimator:
+    def estimator_(self) -> EstimatorLike:
+        """The report's fitted estimator."""
         if self._initialized_with_data_op:
-            return self._estimator
-        return to_estimator(self._estimator)
+            return self.learner_
+        return to_estimator(self.learner_)
 
     @property
     def X_train(self) -> ArrayLike | None:
@@ -770,10 +778,10 @@ def fit(self) -> str | bool:
 
     @property
     def estimator_name_(self) -> str:
-        if isinstance(self._raw_estimator, Pipeline):
-            name = self._raw_estimator[-1].__class__.__name__
+        if isinstance(self._original_estimator, Pipeline):
+            name = self._original_estimator[-1].__class__.__name__
         else:
-            name = self._raw_estimator.__class__.__name__
+            name = self._original_estimator.__class__.__name__
         return name
 
     ####################################################################################