MNT Completes position arg deprecation (scikit-learn#17272)

* ENH Adds public functions with position args warning

* BUG Circlar import

* STY

* BUG Add keywords

* BUG Fixes warnings

* ENH Adds other public functions

* CLN Suggestion

* CLN Suggestion

* REV Revert pairwise

* ENH Positoinal args for compute_class_weight

Author: thomasjpfan

examples/linear_model/plot_lasso_coordinate_descent_path.py

@@ -31,11 +31,11 @@
 eps = 5e-3  # the smaller it is the longer is the path
 
 print("Computing regularization path using the lasso...")
-alphas_lasso, coefs_lasso, _ = lasso_path(X, y, eps, fit_intercept=False)
+alphas_lasso, coefs_lasso, _ = lasso_path(X, y, eps=eps, fit_intercept=False)
 
 print("Computing regularization path using the positive lasso...")
 alphas_positive_lasso, coefs_positive_lasso, _ = lasso_path(
-    X, y, eps, positive=True, fit_intercept=False)
+    X, y, eps=eps, positive=True, fit_intercept=False)
 print("Computing regularization path using the elastic net...")
 alphas_enet, coefs_enet, _ = enet_path(
     X, y, eps=eps, l1_ratio=0.8, fit_intercept=False)

sklearn/calibration.py

@@ -506,7 +506,8 @@ def predict(self, T):
         return expit(-(self.a_ * T + self.b_))
 
 
-def calibration_curve(y_true, y_prob, normalize=False, n_bins=5,
+@_deprecate_positional_args
+def calibration_curve(y_true, y_prob, *, normalize=False, n_bins=5,
                       strategy='uniform'):
     """Compute true and predicted probabilities for a calibration curve.
 

sklearn/cluster/_affinity_propagation.py

@@ -30,8 +30,9 @@ def all_equal_similarities():
     return all_equal_preferences() and all_equal_similarities()
 
 
-def affinity_propagation(S, preference=None, convergence_iter=15, max_iter=200,
-                         damping=0.5, copy=True, verbose=False,
+@_deprecate_positional_args
+def affinity_propagation(S, *, preference=None, convergence_iter=15,
+                         max_iter=200, damping=0.5, copy=True, verbose=False,
                          return_n_iter=False, random_state='warn'):
     """Perform Affinity Propagation Clustering of data
 
@@ -411,7 +412,8 @@ def fit(self, X, y=None):
 
         self.cluster_centers_indices_, self.labels_, self.n_iter_ = \
             affinity_propagation(
-                self.affinity_matrix_, self.preference, max_iter=self.max_iter,
+                self.affinity_matrix_, preference=self.preference,
+                max_iter=self.max_iter,
                 convergence_iter=self.convergence_iter, damping=self.damping,
                 copy=self.copy, verbose=self.verbose, return_n_iter=True,
                 random_state=self.random_state)

sklearn/cluster/_agglomerative.py

@@ -134,7 +134,8 @@ def _single_linkage_tree(connectivity, n_samples, n_nodes, n_clusters,
 ###############################################################################
 # Hierarchical tree building functions
 
-def ward_tree(X, connectivity=None, n_clusters=None, return_distance=False):
+@_deprecate_positional_args
+def ward_tree(X, *, connectivity=None, n_clusters=None, return_distance=False):
     """Ward clustering based on a Feature matrix.
 
     Recursively merges the pair of clusters that minimally increases
@@ -875,7 +876,7 @@ def fit(self, X, y=None):
         distance_threshold = self.distance_threshold
 
         return_distance = distance_threshold is not None
-        out = memory.cache(tree_builder)(X, connectivity,
+        out = memory.cache(tree_builder)(X, connectivity=connectivity,
                                          n_clusters=n_clusters,
                                          return_distance=return_distance,
                                          **kwargs)

sklearn/cluster/_dbscan.py

@@ -20,9 +20,10 @@
 from ._dbscan_inner import dbscan_inner
 
 
-def dbscan(X, eps=0.5, min_samples=5, metric='minkowski', metric_params=None,
-           algorithm='auto', leaf_size=30, p=2, sample_weight=None,
-           n_jobs=None):
+@_deprecate_positional_args
+def dbscan(X, eps=0.5, *, min_samples=5, metric='minkowski',
+           metric_params=None, algorithm='auto', leaf_size=30, p=2,
+           sample_weight=None, n_jobs=None):
     """Perform DBSCAN clustering from vector array or distance matrix.
 
     Read more in the :ref:`User Guide <dbscan>`.

sklearn/cluster/_kmeans.py

@@ -182,7 +182,8 @@ def _check_normalize_sample_weight(sample_weight, X):
     return sample_weight
 
 
-def k_means(X, n_clusters, sample_weight=None, init='k-means++',
+@_deprecate_positional_args
+def k_means(X, n_clusters, *, sample_weight=None, init='k-means++',
             precompute_distances='deprecated', n_init=10, max_iter=300,
             verbose=False, tol=1e-4, random_state=None, copy_x=True,
             n_jobs='deprecated', algorithm="auto", return_n_iter=False):

sklearn/cluster/_mean_shift.py

@@ -26,7 +26,8 @@
 from ..metrics.pairwise import pairwise_distances_argmin
 
 
-def estimate_bandwidth(X, quantile=0.3, n_samples=None, random_state=0,
+@_deprecate_positional_args
+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.
 
@@ -106,7 +107,8 @@ def _mean_shift_single_seed(my_mean, X, nbrs, max_iter):
     return tuple(my_mean), len(points_within), completed_iterations
 
 
-def mean_shift(X, bandwidth=None, seeds=None, bin_seeding=False,
+@_deprecate_positional_args
+def mean_shift(X, *, bandwidth=None, seeds=None, bin_seeding=False,
                min_bin_freq=1, cluster_all=True, max_iter=300,
                n_jobs=None):
     """Perform mean shift clustering of data using a flat kernel.

sklearn/cluster/_optics.py

@@ -261,13 +261,13 @@ def fit(self, X, y=None):
         # Extract clusters from the calculated orders and reachability
         if self.cluster_method == 'xi':
             labels_, clusters_ = cluster_optics_xi(
-                self.reachability_,
-                self.predecessor_,
-                self.ordering_,
-                self.min_samples,
-                self.min_cluster_size,
-                self.xi,
-                self.predecessor_correction)
+                reachability=self.reachability_,
+                predecessor=self.predecessor_,
+                ordering=self.ordering_,
+                min_samples=self.min_samples,
+                min_cluster_size=self.min_cluster_size,
+                xi=self.xi,
+                predecessor_correction=self.predecessor_correction)
             self.cluster_hierarchy_ = clusters_
         elif self.cluster_method == 'dbscan':
             if self.eps is None:
@@ -279,10 +279,10 @@ def fit(self, X, y=None):
                 raise ValueError('Specify an epsilon smaller than %s. Got %s.'
                                  % (self.max_eps, eps))
 
-            labels_ = cluster_optics_dbscan(self.reachability_,
-                                            self.core_distances_,
-                                            self.ordering_,
-                                            eps)
+            labels_ = cluster_optics_dbscan(
+                reachability=self.reachability_,
+                core_distances=self.core_distances_,
+                ordering=self.ordering_, eps=eps)
 
         self.labels_ = labels_
         return self
@@ -339,7 +339,8 @@ def _compute_core_distances_(X, neighbors, min_samples, working_memory):
     return core_distances
 
 
-def compute_optics_graph(X, min_samples, max_eps, metric, p, metric_params,
+@_deprecate_positional_args
+def compute_optics_graph(X, *, min_samples, max_eps, metric, p, metric_params,
                          algorithm, leaf_size, n_jobs):
     """Computes the OPTICS reachability graph.
 
@@ -538,7 +539,8 @@ def _set_reach_dist(core_distances_, reachability_, predecessor_,
     predecessor_[unproc[improved]] = point_index
 
 
-def cluster_optics_dbscan(reachability, core_distances, ordering, eps):
+@_deprecate_positional_args
+def cluster_optics_dbscan(*, reachability, core_distances, ordering, eps):
     """Performs DBSCAN extraction for an arbitrary epsilon.
 
     Extracting the clusters runs in linear time. Note that this results in
@@ -577,7 +579,7 @@ def cluster_optics_dbscan(reachability, core_distances, ordering, eps):
     return labels
 
 
-def cluster_optics_xi(reachability, predecessor, ordering, min_samples,
+def cluster_optics_xi(*, reachability, predecessor, ordering, min_samples,
                       min_cluster_size=None, xi=0.05,
                       predecessor_correction=True):
     """Automatically extract clusters according to the Xi-steep method.

sklearn/cluster/_spectral.py

@@ -18,7 +18,8 @@
 from ._kmeans import k_means
 
 
-def discretize(vectors, copy=True, max_svd_restarts=30, n_iter_max=20,
+@_deprecate_positional_args
+def discretize(vectors, *, copy=True, max_svd_restarts=30, n_iter_max=20,
                random_state=None):
     """Search for a partition matrix (clustering) which is closest to the
     eigenvector embedding.
@@ -156,7 +157,8 @@ def discretize(vectors, copy=True, max_svd_restarts=30, n_iter_max=20,
     return labels
 
 
-def spectral_clustering(affinity, n_clusters=8, n_components=None,
+@_deprecate_positional_args
+def spectral_clustering(affinity, *, n_clusters=8, n_components=None,
                         eigen_solver=None, random_state=None, n_init=10,
                         eigen_tol=0.0, assign_labels='kmeans'):
     """Apply clustering to a projection of the normalized Laplacian.

sklearn/cluster/tests/test_hierarchical.py

@@ -74,16 +74,16 @@ def test_structured_linkage_tree():
     connectivity = grid_to_graph(*mask.shape)
     for tree_builder in _TREE_BUILDERS.values():
         children, n_components, n_leaves, parent = \
-            tree_builder(X.T, connectivity)
+            tree_builder(X.T, connectivity=connectivity)
         n_nodes = 2 * X.shape[1] - 1
         assert len(children) + n_leaves == n_nodes
         # Check that ward_tree raises a ValueError with a connectivity matrix
         # of the wrong shape
         with pytest.raises(ValueError):
-            tree_builder(X.T, np.ones((4, 4)))
+            tree_builder(X.T, connectivity=np.ones((4, 4)))
         # Check that fitting with no samples raises an error
         with pytest.raises(ValueError):
-            tree_builder(X.T[:0], connectivity)
+            tree_builder(X.T[:0], connectivity=connectivity)
 
 
 def test_unstructured_linkage_tree():
@@ -116,7 +116,8 @@ def test_height_linkage_tree():
     X = rng.randn(50, 100)
     connectivity = grid_to_graph(*mask.shape)
     for linkage_func in _TREE_BUILDERS.values():
-        children, n_nodes, n_leaves, parent = linkage_func(X.T, connectivity)
+        children, n_nodes, n_leaves, parent = linkage_func(
+            X.T, connectivity=connectivity)
         n_nodes = 2 * X.shape[1] - 1
         assert len(children) + n_leaves == n_nodes
 
@@ -298,7 +299,8 @@ def test_sparse_scikit_vs_scipy():
             out = hierarchy.linkage(X, method=linkage)
 
             children_ = out[:, :2].astype(np.int, copy=False)
-            children, _, n_leaves, _ = _TREE_BUILDERS[linkage](X, connectivity)
+            children, _, n_leaves, _ = _TREE_BUILDERS[linkage](
+                X, connectivity=connectivity)
 
             # Sort the order of child nodes per row for consistency
             children.sort(axis=1)