done

Author: Sharkyii

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

@@ -407,10 +407,10 @@ class is set to the one provided when creating the report. If `None`,
                             names=["Metric", "Label / Average"],
                         )
                     else:
-                        index = pd.Index([metric_name], name="Metric")
+                        index = pd.Index([metric_name], name="Metric", dtype=object)
                     score_array = np.array(score).reshape(-1, 1)
                 else:
-                    index = pd.Index([metric_name], name="Metric")
+                    index = pd.Index([metric_name], name="Metric", dtype=object)
                     score_array = np.array(score).reshape(-1, 1)
             elif self._parent._ml_task == "multiclass-classification":
                 if isinstance(score, dict):
@@ -430,7 +430,7 @@ class is set to the one provided when creating the report. If `None`,
                     )
                     score_array = np.array(score).reshape(-1, 1)
                 else:
-                    index = pd.Index([metric_name], name="Metric")
+                    index = pd.Index([metric_name], name="Metric", dtype=object)
                     score_array = np.array(score).reshape(-1, 1)
             elif self._parent._ml_task in ("regression", "multioutput-regression"):
                 if isinstance(score, list):
@@ -440,7 +440,7 @@ class is set to the one provided when creating the report. If `None`,
                     )
                     score_array = np.array(score).reshape(-1, 1)
                 else:
-                    index = pd.Index([metric_name], name="Metric")
+                    index = pd.Index([metric_name], name="Metric", dtype=object)
                     score_array = np.array(score).reshape(-1, 1)
             else:  # unknown task - try our best
                 index = None if isinstance(score, Iterable) else [metric_name]

skore/src/skore/_sklearn/_plot/data/table_report.py

@@ -65,11 +65,12 @@ def _truncate_top_k_categories(
             {v: ellide_string(v, max_len=20) for v in values if isinstance(v, str)}
         )
     else:
+        original_dtype = col.dtype
         col[~keep] = other_label
         col = col.apply(
             lambda x: ellide_string(x, max_len=20) if isinstance(x, str) else x
         )
-        col = col.astype(object)
+        col = col.astype(original_dtype)
     return col
 
 
@@ -290,7 +291,7 @@ def _plot_matplotlib(
         hue: str | None = None,
         kind: Literal["dist", "corr"] = "dist",
         top_k_categories: int = 20,
-    ) -> None:
+    ) -> tuple[Figure, Axes]:
         """Matplotlib implementation of the `plot` method."""
         self.figure_, self.ax_ = plt.subplots()
         if kind == "dist":
@@ -306,6 +307,8 @@ def _plot_matplotlib(
                         y=y,
                         k=top_k_categories,
                         histplot_kwargs=self._default_histplot_kwargs,
+                        figure=self.figure_,
+                        ax=self.ax_,
                     )
                 case _:
                     self._plot_distribution_2d(
@@ -317,6 +320,8 @@ def _plot_matplotlib(
                         stripplot_kwargs=self._default_stripplot_kwargs,
                         boxplot_kwargs=self._default_boxplot_kwargs,
                         heatmap_kwargs=self._default_heatmap_kwargs,
+                        figure=self.figure_,
+                        ax=self.ax_,
                     )
 
         elif kind == "corr":
@@ -327,18 +332,22 @@ def _plot_matplotlib(
                     raise ValueError(
                         f"When {kind=!r}, {param_name!r} argument must be None."
                     )
-            self._plot_cramer(heatmap_kwargs=self._default_heatmap_kwargs)
+            self._plot_cramer(heatmap_kwargs=self._default_heatmap_kwargs, ax=self.ax_)
 
         else:
             raise ValueError(f"'kind' options are 'dist', 'corr', got {kind!r}.")
 
+        return (self.figure_, self.ax_)
+
     def _plot_distribution_1d(
         self,
         *,
         x: str | None,
         y: str | None,
         k: int,
         histplot_kwargs: dict[str, Any],
+        figure: Figure,
+        ax: Axes,
     ) -> None:
         """Plot 1-dimensional distribution of a feature.
 
@@ -387,16 +396,16 @@ def _plot_distribution_1d(
             histplot_params = {"x": column}
             despine_params = {"bottom": is_categorical}
             if duration_unit is not None:
-                self.ax_.set(xlabel=f"{duration_unit.capitalize()}s")
+                ax.set(xlabel=f"{duration_unit.capitalize()}s")
         else:  # y is not None
             histplot_params = {"y": column}
             despine_params = {"left": is_categorical}
             if duration_unit is not None:
-                self.ax_.set(ylabel=f"{duration_unit.capitalize()}s")
+                ax.set(ylabel=f"{duration_unit.capitalize()}s")
 
-        sns.histplot(ax=self.ax_, **histplot_params, **histplot_kwargs_validated)
+        sns.histplot(ax=ax, **histplot_params, **histplot_kwargs_validated)
         sns.despine(
-            self.figure_,
+            figure,
             top=True,
             right=True,
             trim=True,
@@ -406,17 +415,17 @@ def _plot_distribution_1d(
 
         if is_categorical:
             _resize_categorical_axis(
-                figure=self.figure_,
-                ax=self.ax_,
+                figure=figure,
+                ax=ax,
                 n_categories=sbd.n_unique(column),
                 is_x_axis=x is not None,
             )
 
         if x is not None and any(
-            len(label.get_text()) > 1 for label in self.ax_.get_xticklabels()
+            len(label.get_text()) > 1 for label in ax.get_xticklabels()
         ):
             # rotate only for string longer than 1 character
-            _rotate_ticklabels(self.ax_, rotation=45)
+            _rotate_ticklabels(ax, rotation=45)
 
     def _plot_distribution_2d(
         self,
@@ -429,6 +438,8 @@ def _plot_distribution_2d(
         scatterplot_kwargs: dict[str, Any],
         hue: str | None = None,
         k: int = 20,
+        figure: Figure,
+        ax: Axes,
     ) -> None:
         """Plot 2-dimensional distribution of two features.
 
@@ -478,7 +489,7 @@ def _plot_distribution_2d(
                 x=x,
                 y=y,
                 hue=hue,
-                ax=self.ax_,
+                ax=ax,
                 **scatterplot_kwargs_validated,
             )
         elif is_x_num or is_y_num:
@@ -512,23 +523,21 @@ def _plot_distribution_2d(
             else:
                 x = _truncate_top_k_categories(x, k)
 
-            sns.boxplot(x=x, y=y, ax=self.ax_, **boxplot_kwargs_validated)
-            sns.stripplot(x=x, y=y, hue=hue, ax=self.ax_, **stripplot_kwargs_validated)
+            sns.boxplot(x=x, y=y, ax=ax, **boxplot_kwargs_validated)
+            sns.stripplot(x=x, y=y, hue=hue, ax=ax, **stripplot_kwargs_validated)
 
             _resize_categorical_axis(
-                figure=self.figure_,
-                ax=self.ax_,
+                figure=figure,
+                ax=ax,
                 n_categories=sbd.n_unique(y) if is_x_num else sbd.n_unique(x),
                 is_x_axis=not is_x_num,
             )
             if is_x_num:
                 despine_params["left"] = True
             else:
                 despine_params["bottom"] = True
-                if any(
-                    len(label.get_text()) > 1 for label in self.ax_.get_xticklabels()
-                ):
-                    _rotate_ticklabels(self.ax_, rotation=45)
+                if any(len(label.get_text()) > 1 for label in ax.get_xticklabels()):
+                    _rotate_ticklabels(ax, rotation=45)
         else:
             if (hue is not None) and (not sbd.is_numeric(hue)):
                 raise ValueError(
@@ -576,9 +585,9 @@ def _plot_distribution_2d(
                 },
                 heatmap_kwargs,
             )
-            sns.heatmap(contingency_table, ax=self.ax_, **heatmap_kwargs_validated)
+            sns.heatmap(contingency_table, ax=ax, **heatmap_kwargs_validated)
             despine_params.update(left=True, bottom=True)
-            self.ax_.tick_params(axis="both", length=0)
+            ax.tick_params(axis="both", length=0)
 
             for is_x_axis, x_or_y in zip(
                 [True, False],
@@ -589,26 +598,28 @@ def _plot_distribution_2d(
                 strict=False,
             ):
                 _resize_categorical_axis(
-                    figure=self.figure_,
-                    ax=self.ax_,
+                    figure=figure,
+                    ax=ax,
                     n_categories=sbd.n_unique(x_or_y),
                     is_x_axis=is_x_axis,
                     size_per_category=size_per_category,
                 )
 
-        sns.despine(self.figure_, **despine_params)
+        sns.despine(figure, **despine_params)
 
-        self.ax_.set(xlabel=sbd.name(x), ylabel=sbd.name(y))
-        if self.ax_.legend_ is not None:
-            sns.move_legend(self.ax_, (1.05, 0.0))
+        ax.set(xlabel=sbd.name(x), ylabel=sbd.name(y))
+        if ax.legend_ is not None:
+            sns.move_legend(ax, (1.05, 0.0))
 
-    def _plot_cramer(self, *, heatmap_kwargs: dict[str, Any]) -> None:
+    def _plot_cramer(self, *, heatmap_kwargs: dict[str, Any], ax: Axes) -> None:
         """Plot Cramer's V correlation among all columns.
 
         Parameters
         ----------
         heatmap_kwargs : dict, default=None
             Keyword arguments to be passed to heatmap.
+        ax : Axes
+            The axes to plot on.
         """
         heatmap_kwargs_validated = _validate_style_kwargs(
             {
@@ -632,8 +643,8 @@ def _plot_cramer(self, *, heatmap_kwargs: dict[str, Any]) -> None:
         # and keep the diagonal as well.
         mask = np.triu(np.ones_like(cramer_v_table, dtype=bool), k=1)
 
-        sns.heatmap(cramer_v_table, mask=mask, ax=self.ax_, **heatmap_kwargs_validated)
-        self.ax_.set(title="Cramer's V Correlation")
+        sns.heatmap(cramer_v_table, mask=mask, ax=ax, **heatmap_kwargs_validated)
+        ax.set(title="Cramer's V Correlation")
 
     def frame(
         self, *, kind: Literal["dataset", "top-associations"] = "dataset"

skore/src/skore/_sklearn/_plot/metrics/confusion_matrix.py

@@ -3,7 +3,6 @@
 
 import numpy as np
 import pandas as pd
-import seaborn
 import seaborn as sns
 from numpy.typing import NDArray
 from sklearn.metrics import confusion_matrix as sklearn_confusion_matrix
@@ -54,6 +53,21 @@ class ConfusionMatrixDisplay(_ClassifierDisplayMixin, DisplayMixin):
         The estimator's method that was used to get the predictions. The possible
         values are: "predict", "predict_proba", and "decision_function".
 
+    Attributes
+    ----------
+    thresholds : ndarray of shape (n_thresholds,)
+        Thresholds of the decision function. Each threshold is associated with a
+        confusion matrix. Only available for binary classification. Thresholds are
+        sorted in ascending order.
+
+    facet_ : seaborn FacetGrid
+        FacetGrid containing the confusion matrix.
+
+    figure_ : matplotlib Figure
+        Figure containing the confusion matrix.
+
+    ax_ : matplotlib Axes
+        Axes with confusion matrix.
     """
 
     _default_heatmap_kwargs: dict = {
@@ -95,7 +109,7 @@ def plot(
         normalize: Literal["true", "pred", "all"] | None = None,
         threshold_value: float | None = None,
         subplot_by: Literal["split", "estimator", "auto"] | None = "auto",
-    ) -> seaborn.FacetGrid:
+    ):
         """Plot the confusion matrix.
 
         In binary classification, the confusion matrix can be displayed at various
@@ -124,8 +138,8 @@ def plot(
 
         Returns
         -------
-        facet : seaborn.FacetGrid
-            Confusion matrix visualization.
+        self : ConfusionMatrixDisplay
+            Configured with the confusion matrix.
         """
         return self._plot(
             normalize=normalize,
@@ -139,7 +153,7 @@ def _plot_matplotlib(
         normalize: Literal["true", "pred", "all"] | None = None,
         threshold_value: float | None = None,
         subplot_by: Literal["split", "estimator", "auto"] | None = "auto",
-    ) -> seaborn.FacetGrid:
+    ) -> sns.axisgrid.FacetGrid:
         """Matplotlib implementation of the `plot` method.
 
         Parameters
@@ -192,11 +206,11 @@ def _plot_matplotlib(
         facet_grid_kwargs_validated = _validate_style_kwargs(
             {"col": subplot_by_validated, **self._default_facet_grid_kwargs}, {}
         )
-        facet_ = sns.FacetGrid(
+        self.facet_ = sns.FacetGrid(
             data=frame,
             **facet_grid_kwargs_validated,
         )
-        figure_, ax_ = facet_.figure, facet_.axes.flatten()
+        self.figure_, self.ax_ = self.facet_.figure, self.facet_.axes.flatten()
 
         def plot_heatmap(data, **kwargs):
             """Plot heatmap for each facet."""
@@ -214,7 +228,7 @@ def plot_heatmap(data, **kwargs):
 
             sns.heatmap(heatmap_data, **kwargs)
 
-        facet_.map_dataframe(plot_heatmap, **heatmap_kwargs_validated)
+        self.facet_.map_dataframe(plot_heatmap, **heatmap_kwargs_validated)
 
         info_data_source = (
             f"Data source: {self.data_source.capitalize()} set"
@@ -229,10 +243,10 @@ def plot_heatmap(data, **kwargs):
             if threshold_value is None:
                 threshold_value = 0.5 if self.response_method == "predict_proba" else 0
             title = f"{title}\nDecision threshold: {threshold_value:.2f}"
-        figure_.suptitle(f"{title}\n{info_data_source}")
+        self.facet_.figure.suptitle(f"{title}\n{info_data_source}")
 
-        for axis in ax_:
-            axis.set(
+        for ax in self.facet_.axes.flatten():
+            ax.set(
                 xlabel="Predicted label",
                 ylabel="True label",
             )
@@ -242,20 +256,20 @@ def plot_heatmap(data, **kwargs):
                     for label in self.display_labels
                 ]
 
-                axis.set(
+                ax.set(
                     xticklabels=ticklabels,
                     yticklabels=ticklabels,
                 )
 
-                axis.text(
+                ax.text(
                     -0.15,
                     -0.15,
                     "*: the positive class",
                     fontsize=9,
                     style="italic",
                     verticalalignment="bottom",
                     horizontalalignment="left",
-                    transform=axis.transAxes,
+                    transform=ax.transAxes,
                     bbox={
                         "boxstyle": "round",
                         "facecolor": "white",
@@ -264,9 +278,10 @@ def plot_heatmap(data, **kwargs):
                     },
                 )
 
-        if len(ax_) == 1:
-            ax_ = ax_[0]
-        return facet_
+        if len(self.ax_) == 1:
+            self.ax_ = self.ax_[0]
+
+        return self.facet_
 
     def _validate_subplot_by(
         self,