TST better test-coverage in clustering module

Author: amueller

sklearn/cluster/affinity_propagation_.py

@@ -16,8 +16,8 @@
 
 
 def affinity_propagation(S, preference=None, p=None, convergence_iter=15,
-        convit=None, max_iter=200,
-        damping=0.5, copy=True, verbose=False):
+                         convit=None, max_iter=200, damping=0.5, copy=True,
+                         verbose=False):
     """Perform Affinity Propagation Clustering of data
 
     Parameters
@@ -80,16 +80,15 @@ def affinity_propagation(S, preference=None, p=None, convergence_iter=15,
     n_samples = S.shape[0]
 
     if S.shape[0] != S.shape[1]:
-        raise ValueError("S must be a square array (shape=%r)" % S.shape)
+        raise ValueError("S must be a square array (shape=%s)" % repr(S.shape))
 
     if not p is None:
         warnings.warn("p is deprecated and will be removed in version 0.14."
-                " Use ``preference`` instead.", DeprecationWarning)
+                      "Use ``preference`` instead.", DeprecationWarning)
         preference = p
 
     if preference is None:
         preference = np.median(S)
-
     if damping < 0.5 or damping >= 1:
         raise ValueError('damping must be >= 0.5 and < 1')
 
@@ -102,8 +101,8 @@ def affinity_propagation(S, preference=None, p=None, convergence_iter=15,
     R = np.zeros((n_samples, n_samples))  # Initialize messages
 
     # Remove degeneracies
-    S += (np.finfo(np.double).eps * S + np.finfo(np.double).tiny * 100) * \
-         random_state.randn(n_samples, n_samples)
+    S += ((np.finfo(np.double).eps * S + np.finfo(np.double).tiny * 100) *
+          random_state.randn(n_samples, n_samples))
 
     # Execute parallel affinity propagation updates
     e = np.zeros((n_samples, convergence_iter))
@@ -148,8 +147,8 @@ def affinity_propagation(S, preference=None, p=None, convergence_iter=15,
 
         if it >= convergence_iter:
             se = np.sum(e, axis=1)
-            unconverged = np.sum((se == convergence_iter) +\
-                                 (se == 0)) != n_samples
+            unconverged = (np.sum((se == convergence_iter) + (se == 0))
+                           != n_samples)
             if (not unconverged and (K > 0)) or (it == max_iter):
                 if verbose:
                     print "Converged after %d iterations." % it
@@ -246,8 +245,8 @@ class AffinityPropagation(BaseEstimator, ClusterMixin):
     """
 
     def __init__(self, damping=.5, max_iter=200, convergence_iter=15,
-            convit=None, copy=True,
-            preference=None, p=None, affinity='euclidean', verbose=False):
+                 convit=None, copy=True, preference=None, p=None,
+                 affinity='euclidean', verbose=False):
 
         if convit is not None:
             warnings.warn("``convit`` is deprectaed and will be removed in "
@@ -262,7 +261,7 @@ def __init__(self, damping=.5, max_iter=200, convergence_iter=15,
         self.verbose = verbose
         if not p is None:
             warnings.warn("p is deprecated and will be removed in version 0.14"
-                    ". Use ``preference`` instead.", DeprecationWarning)
+                          ". Use ``preference`` instead.", DeprecationWarning)
             preference = p
 
         self.preference = preference
@@ -295,7 +294,7 @@ def fit(self, X):
             self.affinity_matrix_ = -euclidean_distances(X, squared=True)
         else:
             raise ValueError("Affinity must be 'precomputed' or "
-                "'euclidean'. Got %s instead" % str(self.affinity))
+                        "'euclidean'. Got %s instead" % str(self.affinity))
 
         self.cluster_centers_indices_, self.labels_ = affinity_propagation(
                 self.affinity_matrix_, self.preference,

sklearn/cluster/hierarchical.py

@@ -347,7 +347,7 @@ def fit(self, X):
         memory = self.memory
         X = array2d(X)
         if isinstance(memory, basestring):
-            memory = Memory(cachedir=memory)
+            memory = Memory(cachedir=memory, verbose=0)
 
         if not self.connectivity is None:
             if not sparse.issparse(self.connectivity):

sklearn/cluster/k_means_.py

@@ -155,22 +155,22 @@ def k_means(X, n_clusters, init='k-means++', precompute_distances=True,
 
     Parameters
     ----------
-    X: array-like or sparse matrix, shape (n_samples, n_features)
+    X : array-like or sparse matrix, shape (n_samples, n_features)
         The observations to cluster.
 
-    n_clusters: int
+    n_clusters : int
         The number of clusters to form as well as the number of
         centroids to generate.
 
-    max_iter: int, optional, default 300
+    max_iter : int, optional, default 300
         Maximum number of iterations of the k-means algorithm to run.
 
-    n_init: int, optional, default: 10
+    n_init : int, optional, default: 10
         Number of time the k-means algorithm will be run with different
         centroid seeds. The final results will be the best output of
         n_init consecutive runs in terms of inertia.
 
-    init: {'k-means++', 'random', or ndarray, or a callable}, optional
+    init : {'k-means++', 'random', or ndarray, or a callable}, optional
         Method for initialization, default to 'k-means++':
 
         'k-means++' : selects initial cluster centers for k-mean
@@ -186,25 +186,25 @@ def k_means(X, n_clusters, init='k-means++', precompute_distances=True,
         If a callable is passed, it should take arguments X, k and
         and a random state and return an initialization.
 
-    tol: float, optional
+    tol : float, optional
         The relative increment in the results before declaring convergence.
 
-    verbose: boolean, optional
-        Verbosity mode
+    verbose : boolean, optional
+        Verbosity mode.
 
-    random_state: integer or numpy.RandomState, optional
+    random_state : integer or numpy.RandomState, optional
         The generator used to initialize the centers. If an integer is
         given, it fixes the seed. Defaults to the global numpy random
         number generator.
 
-    copy_x: boolean, optional
+    copy_x : boolean, optional
         When pre-computing distances it is more numerically accurate to center
         the data first.  If copy_x is True, then the original data is not
         modified.  If False, the original data is modified, and put back before
         the function returns, but small numerical differences may be introduced
         by subtracting and then adding the data mean.
 
-    n_jobs: int
+    n_jobs : int
         The number of jobs to use for the computation. This works by breaking
         down the pairwise matrix into n_jobs even slices and computing them in
         parallel.
@@ -216,14 +216,14 @@ def k_means(X, n_clusters, init='k-means++', precompute_distances=True,
 
     Returns
     -------
-    centroid: float ndarray with shape (k, n_features)
+    centroid : float ndarray with shape (k, n_features)
         Centroids found at the last iteration of k-means.
 
-    label: integer ndarray with shape (n_samples,)
+    label : integer ndarray with shape (n_samples,)
         label[i] is the code or index of the centroid the
         i'th observation is closest to.
 
-    inertia: float
+    inertia : float
         The final value of the inertia criterion (sum of squared distances to
         the closest centroid for all observations in the training set).
 

sklearn/cluster/tests/test_affinity_propagation.py

@@ -5,7 +5,8 @@
 
 import numpy as np
 
-from sklearn.utils.testing import assert_equal, assert_array_equal
+from sklearn.utils.testing import (assert_equal, assert_array_equal,
+                                   assert_raises)
 from sklearn.cluster.affinity_propagation_ import AffinityPropagation
 from sklearn.cluster.affinity_propagation_ import affinity_propagation
 from sklearn.datasets.samples_generator import make_blobs
@@ -25,7 +26,7 @@ def test_affinity_propagation():
     preference = np.median(S) * 10
     # Compute Affinity Propagation
     cluster_centers_indices, labels = affinity_propagation(S,
-            preference=preference)
+                                       preference=preference)
 
     n_clusters_ = len(cluster_centers_indices)
 
@@ -34,7 +35,7 @@ def test_affinity_propagation():
     af = AffinityPropagation(preference=preference, affinity="precomputed")
     labels_precomputed = af.fit(S).labels_
 
-    af = AffinityPropagation(preference=preference)
+    af = AffinityPropagation(preference=preference, verbose=True)
     labels = af.fit(X).labels_
 
     assert_array_equal(labels, labels_precomputed)
@@ -47,5 +48,11 @@ def test_affinity_propagation():
 
     # Test also with no copy
     _, labels_no_copy = affinity_propagation(S, preference=preference,
-            copy=False)
+                                             copy=False)
     assert_array_equal(labels, labels_no_copy)
+
+    # Test input validation
+    assert_raises(ValueError, affinity_propagation, S[:, :-1])
+    assert_raises(ValueError, affinity_propagation, S, damping=0)
+    af = AffinityPropagation(affinity="unknown")
+    assert_raises(ValueError, af.fit, X)

sklearn/cluster/tests/test_hierarchical.py

@@ -5,6 +5,7 @@
 # Authors: Vincent Michel, 2010, Gael Varoquaux 2012
 # License: BSD-like
 import warnings
+from tempfile import mkdtemp
 
 import numpy as np
 from scipy import sparse
@@ -78,6 +79,10 @@ def test_ward_clustering():
     connectivity = grid_to_graph(*mask.shape)
     clustering = Ward(n_clusters=10, connectivity=connectivity)
     clustering.fit(X)
+    # test caching
+    clustering = Ward(n_clusters=10, connectivity=connectivity,
+                      memory=mkdtemp())
+    clustering.fit(X)
     labels = clustering.labels_
     assert_true(np.size(np.unique(labels)) == 10)
     # Check that we obtain the same solution with early-stopping of the
@@ -94,7 +99,7 @@ def test_ward_clustering():
     assert_raises(TypeError, clustering.fit, X)
     clustering = Ward(n_clusters=10,
                       connectivity=sparse.lil_matrix(
-                                connectivity.todense()[:10, :10]))
+                          connectivity.todense()[:10, :10]))
     assert_raises(ValueError, clustering.fit, X)
 
 
@@ -166,7 +171,7 @@ def test_connectivity_popagation():
                   (.018, .153), (.018, .153), (.018, .153),
                   (.018, .153), (.018, .153), (.018, .153),
                   (.018, .152), (.018, .149), (.018, .144),
-                 ])
+                  ])
     nn = NearestNeighbors(n_neighbors=10, warn_on_equidistant=False).fit(X)
     connectivity = nn.kneighbors_graph(X)
     ward = Ward(n_clusters=4, connectivity=connectivity)