Fix uncomparable values in SimpleImputer tie-breaking strategy (scikit-learn#31820)

AlexandreAbraham · jeremiedbb · betatim · web-flow · commit b10b73a9b982 · 2025-08-21T15:18:33.000Z
Co-authored-by: Jérémie du Boisberranger &lt;jeremie@probabl.ai&gt;
Co-authored-by: Tim Head &lt;betatim@gmail.com&gt;
diff --git a/doc/whats_new/upcoming_changes/sklearn.impute/31820.fix.rst b/doc/whats_new/upcoming_changes/sklearn.impute/31820.fix.rst
@@ -0,0 +1,3 @@
+- Fixed a bug in :class:`impute.SimpleImputer` with `strategy="most_frequent"` when
+  there is a tie in the most frequent value and the input data has mixed types.
+  By :user:`Alexandre Abraham <AlexandreAbraham>`.
diff --git a/sklearn/impute/_base.py b/sklearn/impute/_base.py
@@ -38,6 +38,20 @@ def _check_inputs_dtype(X, missing_values):
         )
 
 
+def _safe_min(items):
+    """Compute the minimum of a list of potentially non-comparable values.
+
+    If values cannot be directly compared due to type incompatibility, the object with
+    the lowest string representation is returned.
+    """
+    try:
+        return min(items)
+    except TypeError as e:
+        if "'<' not supported between" in str(e):
+            return min(items, key=lambda x: (str(type(x)), str(x)))
+        raise  # pragma: no cover
+
+
 def _most_frequent(array, extra_value, n_repeat):
     """Compute the most frequent value in a 1d array extended with
     [extra_value] * n_repeat, where extra_value is assumed to be not part
@@ -50,10 +64,12 @@ def _most_frequent(array, extra_value, n_repeat):
             counter = Counter(array)
             most_frequent_count = counter.most_common(1)[0][1]
             # tie breaking similarly to scipy.stats.mode
-            most_frequent_value = min(
-                value
-                for value, count in counter.items()
-                if count == most_frequent_count
+            most_frequent_value = _safe_min(
+                [
+                    value
+                    for value, count in counter.items()
+                    if count == most_frequent_count
+                ]
             )
         else:
             mode = _mode(array)
@@ -72,7 +88,7 @@ def _most_frequent(array, extra_value, n_repeat):
         return most_frequent_value
     elif most_frequent_count == n_repeat:
         # tie breaking similarly to scipy.stats.mode
-        return min(most_frequent_value, extra_value)
+        return _safe_min([most_frequent_value, extra_value])
 
 
 class _BaseImputer(TransformerMixin, BaseEstimator):
diff --git a/sklearn/impute/tests/test_impute.py b/sklearn/impute/tests/test_impute.py
@@ -1529,6 +1529,26 @@ def test_most_frequent(expected, array, dtype, extra_value, n_repeat):
     )
 
 
+@pytest.mark.parametrize(
+    "expected,array",
+    [
+        ("a", ["a", "b"]),
+        (1, [1, 2]),
+        (None, [None, "a"]),
+        (None, [None, 1]),
+        (None, [None, "a", 1]),
+        (1, [1, "1"]),
+        (1, ["1", 1]),
+    ],
+)
+def test_most_frequent_tie_object(expected, array):
+    """Check the tie breaking behavior of the most frequent strategy.
+
+    Non-regression test for issue #31717.
+    """
+    assert expected == _most_frequent(np.array(array, dtype=object), None, 0)
+
+
 @pytest.mark.parametrize(
     "initial_strategy", ["mean", "median", "most_frequent", "constant"]
 )

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+- Fixed a bug in :class:`impute.SimpleImputer` with `strategy="most_frequent"` when
	`2`	`+ there is a tie in the most frequent value and the input data has mixed types.`
	`3`	+ By :user:`Alexandre Abraham <AlexandreAbraham>`.