scikit-learn · glemaitre · Feb 11, 2022 · Jan 15, 2022 · Jan 15, 2022 · Jan 24, 2022
diff --git a/doc/whats_new/v1.1.rst b/doc/whats_new/v1.1.rst
@@ -617,6 +617,9 @@ Changelog
   left corner of the HTML representation to show how the elements are
   clickable. :pr:`21298` by `Thomas Fan`_.
 
+- |Enhancement| :func:`utils.validation.check_scalar` now has better messages
+  when displaying the type. :pr:`22218` by `Thomas Fan`_.
+
 - |Fix| :func:`check_scalar` raises an error when `include_boundaries={"left", "right"}`
   and the boundaries are not set.
   :pr:`22027` by `Marie Lanternier <mlant>`.

diff --git a/sklearn/cluster/tests/test_birch.py b/sklearn/cluster/tests/test_birch.py
@@ -195,16 +195,14 @@ def test_birch_fit_attributes_deprecated(attribute):
         (
             {"branching_factor": 1.5},
             TypeError,
-            "branching_factor must be an instance of <class 'numbers.Integral'>, not"
-            " <class 'float'>.",
+            "branching_factor must be an instance of int, not float.",
         ),
         ({"branching_factor": -2}, ValueError, "branching_factor == -2, must be > 1."),
         ({"n_clusters": 0}, ValueError, "n_clusters == 0, must be >= 1."),
         (
             {"n_clusters": 2.5},
             TypeError,
-            "n_clusters must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>.",
+            "n_clusters must be an instance of int, not float.",
         ),
         (
             {"n_clusters": "whatever"},

diff --git a/sklearn/cluster/tests/test_dbscan.py b/sklearn/cluster/tests/test_dbscan.py
@@ -436,24 +436,21 @@ def test_dbscan_precomputed_metric_with_initial_rows_zero():
         (
             {"min_samples": 1.5},
             TypeError,
            "min_samples must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>.",
+            "min_samples must be an instance of int, not float.",
         ),
         ({"min_samples": -2}, ValueError, "min_samples == -2, must be >= 1."),
         ({"leaf_size": 0}, ValueError, "leaf_size == 0, must be >= 1."),
         (
             {"leaf_size": 2.5},
             TypeError,
-            "leaf_size must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>.",
+            "leaf_size must be an instance of int, not float.",
         ),
         ({"leaf_size": -3}, ValueError, "leaf_size == -3, must be >= 1."),
         ({"p": -2}, ValueError, "p == -2, must be >= 0.0."),
         (
             {"n_jobs": 2.5},
             TypeError,
-            "n_jobs must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>.",
+            "n_jobs must be an instance of int, not float.",
         ),
     ],
 )

diff --git a/sklearn/cluster/tests/test_spectral.py b/sklearn/cluster/tests/test_spectral.py
@@ -121,17 +121,15 @@ def test_spectral_unknown_assign_labels():
             X,
             {"n_clusters": 1.5},
             TypeError,
-            "n_clusters must be an instance of <class 'numbers.Integral'>,"
-            " not <class 'float'>",
+            "n_clusters must be an instance of int, not float",
         ),
         (X, {"n_init": -1}, ValueError, "n_init == -1, must be >= 1"),
         (X, {"n_init": 0}, ValueError, "n_init == 0, must be >= 1"),
         (
             X,
             {"n_init": 1.5},
             TypeError,
-            "n_init must be an instance of <class 'numbers.Integral'>,"
-            " not <class 'float'>",
+            "n_init must be an instance of int, not float",
         ),
         (X, {"gamma": -1}, ValueError, "gamma == -1, must be >= 1"),
         (X, {"gamma": 0}, ValueError, "gamma == 0, must be >= 1"),

diff --git a/sklearn/cross_decomposition/tests/test_pls.py b/sklearn/cross_decomposition/tests/test_pls.py
@@ -476,7 +476,7 @@ def test_scale_and_stability(Est, X, Y):
         (
             2.0,
             TypeError,
-            "n_components must be an instance of <class 'numbers.Integral'>",
+            "n_components must be an instance of int",
         ),
     ],
 )
@@ -498,7 +498,7 @@ def test_n_components_bounds(Est, n_components, err_type, err_msg):
         (
             2.0,
             TypeError,
-            "n_components must be an instance of <class 'numbers.Integral'>",
+            "n_components must be an instance of int",
         ),
     ],
 )

diff --git a/sklearn/decomposition/tests/test_pca.py b/sklearn/decomposition/tests/test_pca.py
@@ -702,7 +702,7 @@ def test_pca_randomized_svd_n_oversamples():
         (
             {"n_oversamples": 1.5},
             TypeError,
-            "n_oversamples must be an instance of <class 'numbers.Integral'>",
+            "n_oversamples must be an instance of int",
         ),
     ],
 )

diff --git a/sklearn/ensemble/tests/test_gradient_boosting.py b/sklearn/ensemble/tests/test_gradient_boosting.py
@@ -84,21 +84,21 @@ def test_classification_toy(loss):
         (
             {"learning_rate": "foo"},
             TypeError,
-            "learning_rate must be an instance of <class 'numbers.Real'>",
+            "learning_rate must be an instance of float",
         ),
         ({"n_estimators": 0}, ValueError, "n_estimators == 0, must be >= 1"),
         (
             {"n_estimators": 1.5},
             TypeError,
-            "n_estimators must be an instance of <class 'numbers.Integral'>,",
+            "n_estimators must be an instance of int,",
         ),
         ({"loss": "foobar"}, ValueError, "Loss 'foobar' not supported"),
         ({"subsample": 0.0}, ValueError, "subsample == 0.0, must be > 0.0"),
         ({"subsample": 1.1}, ValueError, "subsample == 1.1, must be <= 1.0"),
         (
             {"subsample": "foo"},
             TypeError,
-            "subsample must be an instance of <class 'numbers.Real'>",
+            "subsample must be an instance of float",
         ),
         ({"init": {}}, ValueError, "The init parameter must be an estimator or 'zero'"),
         ({"max_features": 0}, ValueError, "max_features == 0, must be >= 1"),
@@ -125,27 +125,27 @@ def test_classification_toy(loss):
         (
             {"validation_fraction": "foo"},
             TypeError,
-            "validation_fraction must be an instance of <class 'numbers.Real'>",
+            "validation_fraction must be an instance of float",
         ),
         ({"n_iter_no_change": 0}, ValueError, "n_iter_no_change == 0, must be >= 1"),
         (
             {"n_iter_no_change": 1.5},
             TypeError,
-            "n_iter_no_change must be an instance of <class 'numbers.Integral'>,",
+            "n_iter_no_change must be an instance of int,",
         ),
         ({"tol": 0.0}, ValueError, "tol == 0.0, must be > 0.0"),
         (
             {"tol": "foo"},
             TypeError,
-            "tol must be an instance of <class 'numbers.Real'>,",
+            "tol must be an instance of float,",
         ),
         # The following parameters are checked in BaseDecisionTree
         ({"min_samples_leaf": 0}, ValueError, "min_samples_leaf == 0, must be >= 1"),
         ({"min_samples_leaf": 0.0}, ValueError, "min_samples_leaf == 0.0, must be > 0"),
         (
             {"min_samples_leaf": "foo"},
             TypeError,
-            "min_samples_leaf must be an instance of <class 'numbers.Real'>",
+            "min_samples_leaf must be an instance of float",
         ),
         ({"min_samples_split": 1}, ValueError, "min_samples_split == 1, must be >= 2"),
         (
@@ -161,7 +161,7 @@ def test_classification_toy(loss):
         (
             {"min_samples_split": "foo"},
             TypeError,
-            "min_samples_split must be an instance of <class 'numbers.Real'>",
+            "min_samples_split must be an instance of float",
         ),
         (
             {"min_weight_fraction_leaf": -1},
@@ -176,19 +176,19 @@ def test_classification_toy(loss):
         (
             {"min_weight_fraction_leaf": "foo"},
             TypeError,
-            "min_weight_fraction_leaf must be an instance of <class 'numbers.Real'>",
+            "min_weight_fraction_leaf must be an instance of float",
         ),
         ({"max_leaf_nodes": 0}, ValueError, "max_leaf_nodes == 0, must be >= 2"),
         (
             {"max_leaf_nodes": 1.5},
             TypeError,
-            "max_leaf_nodes must be an instance of <class 'numbers.Integral'>",
+            "max_leaf_nodes must be an instance of int",
         ),
         ({"max_depth": -1}, ValueError, "max_depth == -1, must be >= 1"),
         (
             {"max_depth": 1.1},
             TypeError,
-            "max_depth must be an instance of <class 'numbers.Integral'>",
+            "max_depth must be an instance of int",
         ),
         (
             {"min_impurity_decrease": -1},
@@ -198,13 +198,13 @@ def test_classification_toy(loss):
         (
             {"min_impurity_decrease": "foo"},
             TypeError,
-            "min_impurity_decrease must be an instance of <class 'numbers.Real'>",
+            "min_impurity_decrease must be an instance of float",
         ),
         ({"ccp_alpha": -1.0}, ValueError, "ccp_alpha == -1.0, must be >= 0.0"),
         (
             {"ccp_alpha": "foo"},
             TypeError,
-            "ccp_alpha must be an instance of <class 'numbers.Real'>",
+            "ccp_alpha must be an instance of float",
         ),
         ({"criterion": "mae"}, ValueError, "criterion='mae' is not supported."),
     ],

diff --git a/sklearn/ensemble/tests/test_weight_boosting.py b/sklearn/ensemble/tests/test_weight_boosting.py
@@ -564,8 +564,7 @@ def test_adaboostregressor_sample_weight():
         (
             {"n_estimators": 1.5},
             TypeError,
-            "n_estimators must be an instance of <class 'numbers.Integral'>,"
-            " not <class 'float'>",
+            "n_estimators must be an instance of int, not float",
         ),
         ({"learning_rate": -1}, ValueError, "learning_rate == -1, must be > 0."),
         ({"learning_rate": 0}, ValueError, "learning_rate == 0, must be > 0."),

diff --git a/sklearn/feature_extraction/tests/test_text.py b/sklearn/feature_extraction/tests/test_text.py
@@ -869,8 +869,7 @@ def test_vectorizer_min_df():
         (
             {"max_features": 3.5},
             TypeError,
-            "max_features must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>",
+            "max_features must be an instance of int, not float",
         ),
     ),
 )

diff --git a/sklearn/linear_model/_glm/tests/test_glm.py b/sklearn/linear_model/_glm/tests/test_glm.py
@@ -142,52 +142,47 @@ def test_glm_solver_argument(solver):
         (
             {"max_iter": "not a number"},
             TypeError,
-            "max_iter must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'str'>",
+            "max_iter must be an instance of int, not str",
         ),
         (
             {"max_iter": [1]},
             TypeError,
-            "max_iter must be an instance of <class 'numbers.Integral'>,"
-            " not <class 'list'>",
+                "max_iter must be an instance of int, not list",
         ),
         (
             {"max_iter": 5.5},
             TypeError,
-            "max_iter must be an instance of <class 'numbers.Integral'>,"
-            " not <class 'float'>",
+            "max_iter must be an instance of int, not float",
         ),
         ({"alpha": -1}, ValueError, "alpha == -1, must be >= 0.0"),
         (
             {"alpha": "1"},
             TypeError,
-            "alpha must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "alpha must be an instance of float, not str",
         ),
         ({"tol": -1.0}, ValueError, "tol == -1.0, must be > 0."),
         ({"tol": 0.0}, ValueError, "tol == 0.0, must be > 0.0"),
         ({"tol": 0}, ValueError, "tol == 0, must be > 0.0"),
         (
             {"tol": "1"},
             TypeError,
-            "tol must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "tol must be an instance of float, not str",
         ),
         (
             {"tol": [1e-3]},
             TypeError,
-            "tol must be an instance of <class 'numbers.Real'>, not <class 'list'>",
+            "tol must be an instance of float, not list",
         ),
         ({"verbose": -1}, ValueError, "verbose == -1, must be >= 0."),
         (
             {"verbose": "1"},
             TypeError,
-            "verbose must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'str'>",
+            "verbose must be an instance of int, not str",
         ),
         (
             {"verbose": 1.0},
             TypeError,
-            "verbose must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'float'>",
+            "verbose must be an instance of int, not float",
         ),
     ],
 )

diff --git a/sklearn/linear_model/tests/test_coordinate_descent.py b/sklearn/linear_model/tests/test_coordinate_descent.py
@@ -115,20 +115,19 @@ def test_assure_warning_when_normalize(CoordinateDescentModel, normalize, n_warn
         (
             {"l1_ratio": "1"},
             TypeError,
-            "l1_ratio must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "l1_ratio must be an instance of float, not str",
         ),
         ({"tol": -1.0}, ValueError, "tol == -1.0, must be >= 0."),
         (
             {"tol": "1"},
             TypeError,
-            "tol must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "tol must be an instance of float, not str",
         ),
         ({"max_iter": 0}, ValueError, "max_iter == 0, must be >= 1."),
         (
             {"max_iter": "1"},
             TypeError,
-            "max_iter must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'str'>",
+            "max_iter must be an instance of int, not str",
         ),
     ],
 )

diff --git a/sklearn/linear_model/tests/test_ridge.py b/sklearn/linear_model/tests/test_ridge.py
@@ -342,20 +342,19 @@ def test_ridge_individual_penalties():
         (
             {"alpha": "1"},
             TypeError,
-            "alpha must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "alpha must be an instance of float, not str",
         ),
         ({"max_iter": 0}, ValueError, "max_iter == 0, must be >= 1."),
         (
             {"max_iter": "1"},
             TypeError,
-            "max_iter must be an instance of <class 'numbers.Integral'>, not <class"
-            " 'str'>",
+            "max_iter must be an instance of int, not str",
         ),
         ({"tol": -1.0}, ValueError, "tol == -1.0, must be >= 0."),
         (
             {"tol": "1"},
             TypeError,
-            "tol must be an instance of <class 'numbers.Real'>, not <class 'str'>",
+            "tol must be an instance of float, not str",
         ),
     ],
 )
@@ -1283,8 +1282,7 @@ def test_ridgecv_int_alphas():
         (
             {"alphas": (1, 1.0, "1")},
             TypeError,
-            r"alphas\[2\] must be an instance of <class 'numbers.Real'>, not <class"
-            r" 'str'>",
+            r"alphas\[2\] must be an instance of float, not str",
         ),
     ],
 )

diff --git a/sklearn/preprocessing/tests/test_discretization.py b/sklearn/preprocessing/tests/test_discretization.py
@@ -395,10 +395,7 @@ def test_kbinsdiscretizer_subsample_invalid_type():
         n_bins=10, encode="ordinal", strategy="quantile", subsample="full"
     )
 
-    msg = (
-        "subsample must be an instance of <class 'numbers.Integral'>, not "
-        "<class 'str'>."
-    )
+    msg = "subsample must be an instance of int, not str."
     with pytest.raises(TypeError, match=msg):
         kbd.fit(X)