FIX handle aliases in displays when used as default and provided by user (scikit-learn#30023)

Co-authored-by: Guillaume Lemaitre <guillaume@probabl.ai>
Co-authored-by: Yao Xiao <108576690+Charlie-XIAO@users.noreply.github.com>

Author: 3 people

doc/whats_new/upcoming_changes/many-modules/30023.fix.rst

@@ -0,0 +1,6 @@
+- Classes :class:`metrics.ConfusionMatrixDisplay`,
+  :class:`metrics.RocCurveDisplay`, :class:`calibration.CalibrationDisplay`,
+  :class:`metrics.PrecisionRecallDisplay`, :class:`metrics.PredictionErrorDisplay` and
+  :class:`inspection.PartialDependenceDisplay` now properly handle Matplotlib aliases
+  for style parameters (e.g., `c` and `color`, `ls` and `linestyle`, etc).
+  By :user:`Joseph Barbier <JosephBARBIERDARNAL>`

sklearn/calibration.py

@@ -38,7 +38,7 @@
     StrOptions,
     validate_params,
 )
-from .utils._plotting import _BinaryClassifierCurveDisplayMixin
+from .utils._plotting import _BinaryClassifierCurveDisplayMixin, _validate_style_kwargs
 from .utils._response import _get_response_values, _process_predict_proba
 from .utils.metadata_routing import (
     MetadataRouter,
@@ -1150,10 +1150,10 @@ def plot(self, *, ax=None, name=None, ref_line=True, **kwargs):
             f"(Positive class: {self.pos_label})" if self.pos_label is not None else ""
         )
 
-        line_kwargs = {"marker": "s", "linestyle": "-"}
+        default_line_kwargs = {"marker": "s", "linestyle": "-"}
         if name is not None:
-            line_kwargs["label"] = name
-        line_kwargs.update(**kwargs)
+            default_line_kwargs["label"] = name
+        line_kwargs = _validate_style_kwargs(default_line_kwargs, kwargs)
 
         ref_line_label = "Perfectly calibrated"
         existing_ref_line = ref_line_label in self.ax_.get_legend_handles_labels()[1]

sklearn/inspection/_plot/partial_dependence.py

@@ -18,6 +18,7 @@
 )
 from ...utils._encode import _unique
 from ...utils._optional_dependencies import check_matplotlib_support  # noqa
+from ...utils._plotting import _validate_style_kwargs
 from ...utils.parallel import Parallel, delayed
 from .. import partial_dependence
 from .._pd_utils import _check_feature_names, _get_feature_index
@@ -1294,7 +1295,7 @@ def plot(
         if contour_kw is None:
             contour_kw = {}
         default_contour_kws = {"alpha": 0.75}
-        contour_kw = {**default_contour_kws, **contour_kw}
+        contour_kw = _validate_style_kwargs(default_contour_kws, contour_kw)
 
         n_features = len(self.features)
         is_average_plot = [kind_plot == "average" for kind_plot in kind]
@@ -1422,26 +1423,25 @@ def plot(
                     default_ice_lines_kws = {}
                     default_pd_lines_kws = {}
 
-                ice_lines_kw = {
-                    **default_line_kws,
-                    **default_ice_lines_kws,
-                    **line_kw,
-                    **ice_lines_kw,
-                }
+                default_ice_lines_kws = {**default_line_kws, **default_ice_lines_kws}
+                default_pd_lines_kws = {**default_line_kws, **default_pd_lines_kws}
+
+                line_kw = _validate_style_kwargs(default_line_kws, line_kw)
+
+                ice_lines_kw = _validate_style_kwargs(
+                    _validate_style_kwargs(default_ice_lines_kws, line_kw), ice_lines_kw
+                )
                 del ice_lines_kw["label"]
 
-                pd_line_kw = {
-                    **default_line_kws,
-                    **default_pd_lines_kws,
-                    **line_kw,
-                    **pd_line_kw,
-                }
+                pd_line_kw = _validate_style_kwargs(
+                    _validate_style_kwargs(default_pd_lines_kws, line_kw), pd_line_kw
+                )
 
                 default_bar_kws = {"color": "C0"}
-                bar_kw = {**default_bar_kws, **bar_kw}
+                bar_kw = _validate_style_kwargs(default_bar_kws, bar_kw)
 
                 default_heatmap_kw = {}
-                heatmap_kw = {**default_heatmap_kw, **heatmap_kw}
+                heatmap_kw = _validate_style_kwargs(default_heatmap_kw, heatmap_kw)
 
                 self._plot_one_way_partial_dependence(
                     kind_plot,

sklearn/inspection/_plot/tests/test_plot_partial_dependence.py

@@ -970,6 +970,10 @@ def test_partial_dependence_kind_error(
         ({"color": "r"}, {"color": "g"}, None, ("g", "r")),
         ({"color": "r"}, None, None, ("r", "r")),
         ({"color": "r"}, {"linestyle": "--"}, {"linestyle": "-."}, ("r", "r")),
+        ({"c": "r"}, None, None, ("r", "r")),
+        ({"c": "r", "ls": "-."}, {"color": "g"}, {"color": "b"}, ("g", "b")),
+        ({"c": "r"}, {"c": "g"}, {"c": "b"}, ("g", "b")),
+        ({"c": "r"}, {"ls": "--"}, {"ls": "-."}, ("r", "r")),
     ],
 )
 def test_plot_partial_dependence_lines_kw(
@@ -999,16 +1003,26 @@ def test_plot_partial_dependence_lines_kw(
     )
 
     line = disp.lines_[0, 0, -1]
-    assert line.get_color() == expected_colors[0]
-    if pd_line_kw is not None and "linestyle" in pd_line_kw:
-        assert line.get_linestyle() == pd_line_kw["linestyle"]
+    assert line.get_color() == expected_colors[0], (
+        f"{line.get_color()}!={expected_colors[0]}\n" f"{line_kw} and {pd_line_kw}"
+    )
+    if pd_line_kw is not None:
+        if "linestyle" in pd_line_kw:
+            assert line.get_linestyle() == pd_line_kw["linestyle"]
+        elif "ls" in pd_line_kw:
+            assert line.get_linestyle() == pd_line_kw["ls"]
     else:
         assert line.get_linestyle() == "--"
 
     line = disp.lines_[0, 0, 0]
-    assert line.get_color() == expected_colors[1]
-    if ice_lines_kw is not None and "linestyle" in ice_lines_kw:
-        assert line.get_linestyle() == ice_lines_kw["linestyle"]
+    assert (
+        line.get_color() == expected_colors[1]
+    ), f"{line.get_color()}!={expected_colors[1]}"
+    if ice_lines_kw is not None:
+        if "linestyle" in ice_lines_kw:
+            assert line.get_linestyle() == ice_lines_kw["linestyle"]
+        elif "ls" in ice_lines_kw:
+            assert line.get_linestyle() == ice_lines_kw["ls"]
     else:
         assert line.get_linestyle() == "-"
 

sklearn/metrics/_plot/confusion_matrix.py

@@ -7,6 +7,7 @@
 
 from ...base import is_classifier
 from ...utils._optional_dependencies import check_matplotlib_support
+from ...utils._plotting import _validate_style_kwargs
 from ...utils.multiclass import unique_labels
 from .. import confusion_matrix
 
@@ -145,7 +146,7 @@ def plot(
 
         default_im_kw = dict(interpolation="nearest", cmap=cmap)
         im_kw = im_kw or {}
-        im_kw = {**default_im_kw, **im_kw}
+        im_kw = _validate_style_kwargs(default_im_kw, im_kw)
         text_kw = text_kw or {}
 
         self.im_ = ax.imshow(cm, **im_kw)
@@ -171,7 +172,7 @@ def plot(
                     text_cm = format(cm[i, j], values_format)
 
                 default_text_kwargs = dict(ha="center", va="center", color=color)
-                text_kwargs = {**default_text_kwargs, **text_kw}
+                text_kwargs = _validate_style_kwargs(default_text_kwargs, text_kw)
 
                 self.text_[i, j] = ax.text(j, i, text_cm, **text_kwargs)
 

sklearn/metrics/_plot/precision_recall_curve.py

@@ -3,7 +3,10 @@
 
 from collections import Counter
 
-from ...utils._plotting import _BinaryClassifierCurveDisplayMixin
+from ...utils._plotting import (
+    _BinaryClassifierCurveDisplayMixin,
+    _validate_style_kwargs,
+)
 from .._ranking import average_precision_score, precision_recall_curve
 
 
@@ -178,14 +181,17 @@ def plot(
         """
         self.ax_, self.figure_, name = self._validate_plot_params(ax=ax, name=name)
 
-        line_kwargs = {"drawstyle": "steps-post"}
+        default_line_kwargs = {"drawstyle": "steps-post"}
         if self.average_precision is not None and name is not None:
-            line_kwargs["label"] = f"{name} (AP = {self.average_precision:0.2f})"
+            default_line_kwargs["label"] = (
+                f"{name} (AP = {self.average_precision:0.2f})"
+            )
         elif self.average_precision is not None:
-            line_kwargs["label"] = f"AP = {self.average_precision:0.2f}"
+            default_line_kwargs["label"] = f"AP = {self.average_precision:0.2f}"
         elif name is not None:
-            line_kwargs["label"] = name
-        line_kwargs.update(**kwargs)
+            default_line_kwargs["label"] = name
+
+        line_kwargs = _validate_style_kwargs(default_line_kwargs, kwargs)
 
         (self.line_,) = self.ax_.plot(self.recall, self.precision, **line_kwargs)
 
@@ -214,13 +220,18 @@ def plot(
                     "to automatically set prevalence_pos_label"
                 )
 
-            chance_level_line_kw = {
+            default_chance_level_line_kw = {
                 "label": f"Chance level (AP = {self.prevalence_pos_label:0.2f})",
                 "color": "k",
                 "linestyle": "--",
             }
-            if chance_level_kw is not None:
-                chance_level_line_kw.update(chance_level_kw)
+
+            if chance_level_kw is None:
+                chance_level_kw = {}
+
+            chance_level_line_kw = _validate_style_kwargs(
+                default_chance_level_line_kw, chance_level_kw
+            )
 
             (self.chance_level_,) = self.ax_.plot(
                 (0, 1),

sklearn/metrics/_plot/regression.py

@@ -7,6 +7,7 @@
 
 from ...utils import _safe_indexing, check_random_state
 from ...utils._optional_dependencies import check_matplotlib_support
+from ...utils._plotting import _validate_style_kwargs
 
 
 class PredictionErrorDisplay:
@@ -142,6 +143,9 @@ def plot(
         default_scatter_kwargs = {"color": "tab:blue", "alpha": 0.8}
         default_line_kwargs = {"color": "black", "alpha": 0.7, "linestyle": "--"}
 
+        scatter_kwargs = _validate_style_kwargs(default_scatter_kwargs, scatter_kwargs)
+        line_kwargs = _validate_style_kwargs(default_line_kwargs, line_kwargs)
+
         scatter_kwargs = {**default_scatter_kwargs, **scatter_kwargs}
         line_kwargs = {**default_line_kwargs, **line_kwargs}
 

sklearn/metrics/_plot/roc_curve.py

@@ -1,7 +1,10 @@
 # Authors: The scikit-learn developers
 # SPDX-License-Identifier: BSD-3-Clause
 
-from ...utils._plotting import _BinaryClassifierCurveDisplayMixin
+from ...utils._plotting import (
+    _BinaryClassifierCurveDisplayMixin,
+    _validate_style_kwargs,
+)
 from .._ranking import auc, roc_curve
 
 
@@ -129,24 +132,28 @@ def plot(
         """
         self.ax_, self.figure_, name = self._validate_plot_params(ax=ax, name=name)
 
-        line_kwargs = {}
+        default_line_kwargs = {}
         if self.roc_auc is not None and name is not None:
-            line_kwargs["label"] = f"{name} (AUC = {self.roc_auc:0.2f})"
+            default_line_kwargs["label"] = f"{name} (AUC = {self.roc_auc:0.2f})"
         elif self.roc_auc is not None:
-            line_kwargs["label"] = f"AUC = {self.roc_auc:0.2f}"
+            default_line_kwargs["label"] = f"AUC = {self.roc_auc:0.2f}"
         elif name is not None:
-            line_kwargs["label"] = name
+            default_line_kwargs["label"] = name
 
-        line_kwargs.update(**kwargs)
+        line_kwargs = _validate_style_kwargs(default_line_kwargs, kwargs)
 
-        chance_level_line_kw = {
+        default_chance_level_line_kw = {
             "label": "Chance level (AUC = 0.5)",
             "color": "k",
             "linestyle": "--",
         }
 
-        if chance_level_kw is not None:
-            chance_level_line_kw.update(**chance_level_kw)
+        if chance_level_kw is None:
+            chance_level_kw = {}
+
+        chance_level_kw = _validate_style_kwargs(
+            default_chance_level_line_kw, chance_level_kw
+        )
 
         (self.line_,) = self.ax_.plot(self.fpr, self.tpr, **line_kwargs)
         info_pos_label = (
@@ -164,13 +171,11 @@ def plot(
         )
 
         if plot_chance_level:
-            (self.chance_level_,) = self.ax_.plot(
-                (0, 1), (0, 1), **chance_level_line_kw
-            )
+            (self.chance_level_,) = self.ax_.plot((0, 1), (0, 1), **chance_level_kw)
         else:
             self.chance_level_ = None
 
-        if "label" in line_kwargs or "label" in chance_level_line_kw:
+        if "label" in line_kwargs or "label" in chance_level_kw:
             self.ax_.legend(loc="lower right")
 
         return self

sklearn/metrics/_plot/tests/test_precision_recall_display.py

@@ -82,7 +82,7 @@ def test_precision_recall_display_plotting(
     assert display.chance_level_ is None
 
 
-@pytest.mark.parametrize("chance_level_kw", [None, {"color": "r"}])
+@pytest.mark.parametrize("chance_level_kw", [None, {"color": "r"}, {"c": "r"}])
 @pytest.mark.parametrize("constructor_name", ["from_estimator", "from_predictions"])
 def test_precision_recall_chance_level_line(
     pyplot,

sklearn/metrics/_plot/tests/test_predict_error_display.py

@@ -128,12 +128,21 @@ def test_plot_prediction_error_ax(pyplot, regressor_fitted, class_method):
 
 
 @pytest.mark.parametrize("class_method", ["from_estimator", "from_predictions"])
-def test_prediction_error_custom_artist(pyplot, regressor_fitted, class_method):
-    """Check that we can tune the style of the lines."""
+@pytest.mark.parametrize(
+    "scatter_kwargs",
+    [None, {"color": "blue", "alpha": 0.9}, {"c": "blue", "alpha": 0.9}],
+)
+@pytest.mark.parametrize(
+    "line_kwargs", [None, {"color": "red", "linestyle": "-"}, {"c": "red", "ls": "-"}]
+)
+def test_prediction_error_custom_artist(
+    pyplot, regressor_fitted, class_method, scatter_kwargs, line_kwargs
+):
+    """Check that we can tune the style of the line and the scatter."""
     extra_params = {
         "kind": "actual_vs_predicted",
-        "scatter_kwargs": {"color": "red"},
-        "line_kwargs": {"color": "black"},
+        "scatter_kwargs": scatter_kwargs,
+        "line_kwargs": line_kwargs,
     }
     if class_method == "from_estimator":
         display = PredictionErrorDisplay.from_estimator(
@@ -145,17 +154,16 @@ def test_prediction_error_custom_artist(pyplot, regressor_fitted, class_method):
             y_true=y, y_pred=y_pred, **extra_params
         )
 
-    assert display.line_.get_color() == "black"
-    assert_allclose(display.scatter_.get_edgecolor(), [[1.0, 0.0, 0.0, 0.8]])
-
-    # create a display with the default values
-    if class_method == "from_estimator":
-        display = PredictionErrorDisplay.from_estimator(regressor_fitted, X, y)
+    if line_kwargs is not None:
+        assert display.line_.get_linestyle() == "-"
+        assert display.line_.get_color() == "red"
     else:
-        y_pred = regressor_fitted.predict(X)
-        display = PredictionErrorDisplay.from_predictions(y_true=y, y_pred=y_pred)
-    pyplot.close("all")
+        assert display.line_.get_linestyle() == "--"
+        assert display.line_.get_color() == "black"
+        assert display.line_.get_alpha() == 0.7
 
-    display.plot(**extra_params)
-    assert display.line_.get_color() == "black"
-    assert_allclose(display.scatter_.get_edgecolor(), [[1.0, 0.0, 0.0, 0.8]])
+    if scatter_kwargs is not None:
+        assert_allclose(display.scatter_.get_facecolor(), [[0.0, 0.0, 1.0, 0.9]])
+        assert_allclose(display.scatter_.get_edgecolor(), [[0.0, 0.0, 1.0, 0.9]])
+    else:
+        assert display.scatter_.get_alpha() == 0.8