MAINT Param validation: apply skip nested validation to all functions (scikit-learn#26495)

Author: jeremiedbb

sklearn/calibration.py

@@ -955,7 +955,8 @@ def predict(self, T):
         "pos_label": [Real, str, "boolean", None],
         "n_bins": [Interval(Integral, 1, None, closed="left")],
         "strategy": [StrOptions({"uniform", "quantile"})],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def calibration_curve(
     y_true,

sklearn/cluster/_affinity_propagation.py

@@ -185,7 +185,8 @@ def _affinity_propagation(
     {
         "S": ["array-like"],
         "return_n_iter": ["boolean"],
-    }
+    },
+    prefer_skip_nested_validation=False,
 )
 def affinity_propagation(
     S,

sklearn/cluster/_agglomerative.py

@@ -185,7 +185,8 @@ def _single_linkage_tree(
         "connectivity": ["array-like", "sparse matrix", None],
         "n_clusters": [Interval(Integral, 1, None, closed="left"), None],
         "return_distance": ["boolean"],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def ward_tree(X, *, connectivity=None, n_clusters=None, return_distance=False):
     """Ward clustering based on a Feature matrix.

sklearn/cluster/_kmeans.py

@@ -66,7 +66,8 @@
         "x_squared_norms": ["array-like", None],
         "random_state": ["random_state"],
         "n_local_trials": [Interval(Integral, 1, None, closed="left"), None],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def kmeans_plusplus(
     X,
@@ -293,24 +294,10 @@ def _tolerance(X, tol):
 @validate_params(
     {
         "X": ["array-like", "sparse matrix"],
-        "n_clusters": [Interval(Integral, 1, None, closed="left")],
         "sample_weight": ["array-like", None],
-        "init": [StrOptions({"k-means++", "random"}), callable, "array-like"],
-        "n_init": [
-            StrOptions({"auto"}),
-            Hidden(StrOptions({"warn"})),
-            Interval(Integral, 1, None, closed="left"),
-        ],
-        "max_iter": [Interval(Integral, 1, None, closed="left")],
-        "verbose": [Interval(Integral, 0, None, closed="left"), bool],
-        "tol": [Interval(Real, 0, None, closed="left")],
-        "random_state": ["random_state"],
-        "copy_x": [bool],
-        "algorithm": [
-            StrOptions({"lloyd", "elkan", "auto", "full"}, deprecated={"auto", "full"})
-        ],
         "return_n_iter": [bool],
-    }
+    },
+    prefer_skip_nested_validation=False,
 )
 def k_means(
     X,

sklearn/cluster/_mean_shift.py

@@ -37,7 +37,8 @@
         "n_samples": [Interval(Integral, 1, None, closed="left"), None],
         "random_state": ["random_state"],
         "n_jobs": [Integral, None],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def estimate_bandwidth(X, *, quantile=0.3, n_samples=None, random_state=0, n_jobs=None):
     """Estimate the bandwidth to use with the mean-shift algorithm.
@@ -120,7 +121,10 @@ def _mean_shift_single_seed(my_mean, X, nbrs, max_iter):
     return tuple(my_mean), len(points_within), completed_iterations
 
 
-@validate_params({"X": ["array-like"]})
+@validate_params(
+    {"X": ["array-like"]},
+    prefer_skip_nested_validation=False,
+)
 def mean_shift(
     X,
     *,

sklearn/cluster/_optics.py

@@ -447,7 +447,8 @@ def _compute_core_distances_(X, neighbors, min_samples, working_memory):
         "algorithm": [StrOptions({"auto", "brute", "ball_tree", "kd_tree"})],
         "leaf_size": [Interval(Integral, 1, None, closed="left")],
         "n_jobs": [Integral, None],
-    }
+    },
+    prefer_skip_nested_validation=False,  # metric is not validated yet
 )
 def compute_optics_graph(
     X, *, min_samples, max_eps, metric, p, metric_params, algorithm, leaf_size, n_jobs
@@ -686,7 +687,8 @@ def _set_reach_dist(
         "core_distances": [np.ndarray],
         "ordering": [np.ndarray],
         "eps": [Interval(Real, 0, None, closed="both")],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def cluster_optics_dbscan(*, reachability, core_distances, ordering, eps):
     """Perform DBSCAN extraction for an arbitrary epsilon.
@@ -742,7 +744,8 @@ def cluster_optics_dbscan(*, reachability, core_distances, ordering, eps):
         ],
         "xi": [Interval(Real, 0, 1, closed="both")],
         "predecessor_correction": ["boolean"],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def cluster_optics_xi(
     *,

sklearn/cluster/_spectral.py

@@ -189,7 +189,10 @@ def discretize(
     return labels
 
 
-@validate_params({"affinity": ["array-like", "sparse matrix"]})
+@validate_params(
+    {"affinity": ["array-like", "sparse matrix"]},
+    prefer_skip_nested_validation=False,
+)
 def spectral_clustering(
     affinity,
     *,

sklearn/covariance/_empirical_covariance.py

@@ -54,7 +54,8 @@ def log_likelihood(emp_cov, precision):
     {
         "X": ["array-like"],
         "assume_centered": ["boolean"],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def empirical_covariance(X, *, assume_centered=False):
     """Compute the Maximum likelihood covariance estimator.

sklearn/covariance/_graph_lasso.py

@@ -217,7 +217,8 @@ def alpha_max(emp_cov):
         "cov_init": ["array-like", None],
         "return_costs": ["boolean"],
         "return_n_iter": ["boolean"],
-    }
+    },
+    prefer_skip_nested_validation=False,
 )
 def graphical_lasso(
     emp_cov,

sklearn/covariance/_shrunk_covariance.py

@@ -105,7 +105,8 @@ def _oas(X, *, assume_centered=False):
     {
         "emp_cov": ["array-like"],
         "shrinkage": [Interval(Real, 0, 1, closed="both")],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def shrunk_covariance(emp_cov, shrinkage=0.1):
     """Calculate a covariance matrix shrunk on the diagonal.
@@ -279,7 +280,8 @@ def fit(self, X, y=None):
         "X": ["array-like"],
         "assume_centered": ["boolean"],
         "block_size": [Interval(Integral, 1, None, closed="left")],
-    }
+    },
+    prefer_skip_nested_validation=True,
 )
 def ledoit_wolf_shrinkage(X, assume_centered=False, block_size=1000):
     """Estimate the shrunk Ledoit-Wolf covariance matrix.
@@ -376,7 +378,10 @@ def ledoit_wolf_shrinkage(X, assume_centered=False, block_size=1000):
     return shrinkage
 
 
-@validate_params({"X": ["array-like"]})
+@validate_params(
+    {"X": ["array-like"]},
+    prefer_skip_nested_validation=False,
+)
 def ledoit_wolf(X, *, assume_centered=False, block_size=1000):
     """Estimate the shrunk Ledoit-Wolf covariance matrix.
 
@@ -569,7 +574,10 @@ def fit(self, X, y=None):
 
 
 # OAS estimator
-@validate_params({"X": ["array-like"]})
+@validate_params(
+    {"X": ["array-like"]},
+    prefer_skip_nested_validation=False,
+)
 def oas(X, *, assume_centered=False):
     """Estimate covariance with the Oracle Approximating Shrinkage as proposed in [1]_.