FIX: Wrap csc_row_median around the _get_median imputer function

Author: MechCoder

sklearn/neighbors/nearest_centroid.py

@@ -88,8 +88,8 @@ def fit(self, X, y):
             Target values (integers)
         """
         X, y = check_X_y(X, y, ['csc'])
-        X_sparse = sp.issparse(X)
-        if X_sparse and self.shrink_threshold:
+        is_X_sparse = sp.issparse(X)
+        if is_X_sparse and self.shrink_threshold:
             raise ValueError("threshold shrinking not supported"
                              " for sparse input")
 
@@ -109,13 +109,13 @@ def fit(self, X, y):
         for cur_class in y_ind:
             center_mask = y_ind == cur_class
             nk[cur_class] = np.sum(center_mask)
-            if X_sparse:
+            if is_X_sparse:
                 center_mask = np.where(center_mask)[0]
 
             # XXX: Update other averaging methods according to the metrics.
             if self.metric == "manhattan":
                 # NumPy does not calculate median of sparse matrices.
-                if not X_sparse:
+                if not is_X_sparse:
                     self.centroids_[cur_class] = np.median(X[center_mask], axis=0)
                 else:
                     self.centroids_[cur_class] = csc_row_median(X[center_mask])

sklearn/utils/sparsefuncs.py

@@ -348,7 +348,8 @@ def count_nonzero(X, axis=None, sample_weight=None):
 def csc_row_median(csc):
     """
     Find the median across axis 0 of a CSC matrix.
-    Equivalent to doing np.median(X, axis=0)
+    Wrapper aound the _get_median function in imputer and is equivalent
+    to doing np.median(X, axis=0)
 
     Parameters
     ----------
@@ -361,55 +362,20 @@ def csc_row_median(csc):
         Median. 
 
     """
+    from ..preprocessing.imputation import _get_median
+
     if not isinstance(csc, sp.csc_matrix):
-        warnings.warn("Non CSC matix passed. Will convert to CSC format.")
-        csc = sp.csc_matrix(csc)
+        raise TypeError("Expected matrix of CSC format, got %s" % csc.format)
 
     indptr = csc.indptr
     n_samples, n_features = csc.shape
-
-    # Highly likely that the median of a sparse matrix is zero.
-    # Remains zero if the if/else conditions are not checked below.
     median = np.zeros(n_features)
 
     for f_ind, ptr in enumerate(indptr[:-1]):
-        sorted_nonzero = np.sort(csc.data[ptr: indptr[f_ind + 1]])
-        nz = n_samples - sorted_nonzero.size
-        zero_ind = np.searchsorted(sorted_nonzero, 0)
-        neg_idx = sorted_nonzero[: zero_ind]
-        pos_idx = sorted_nonzero[zero_ind: ]
-        odd = n_samples % 2
-        mid_ind = n_samples // 2
-
-        if odd:
-            # Number of negative terms is greater then (n_features + 1) / 2
-            # which implies the median is negative.
-            if zero_ind > mid_ind:
-                median[f_ind] = sorted_nonzero[mid_ind]
-
-            # The sum of the negative terms and the number of zeros is less
-            # than the (n_features + 1) / 2 which implies the median is positive.
-            elif zero_ind + nz <= mid_ind:
-                median[f_ind] = pos_idx[mid_ind - nz - neg_idx.size]
 
-        else:
-            # The first two conditions are highly unlikely.
-            # When the n_features / 2 is the last negative term and
-            # (n_features / 2) + 1 is zero.
-            if zero_ind == mid_ind:
-                median[f_ind] = neg_idx[-1] / 2.
-
-            # When the n_features / 2 is zero and (n_features / 2) + 1
-            # is the first positive term.
-            elif neg_idx.size + nz == mid_ind:
-                median[f_ind] = pos_idx[0] / 2.
-
-            # Same comments as for the odd case.
-            elif zero_ind > mid_ind:
-                median[f_ind] = (sorted_nonzero[mid_ind - 1] +
-                                 sorted_nonzero[mid_ind]) / 2.
-            elif zero_ind + nz < mid_ind:
-                npz = mid_ind - nz - neg_idx.size
-                median[f_ind] = (pos_idx[npz - 1] + pos_idx[npz]) / 2.
+        # Prevent modifying csc in place
+        data = np.copy(csc.data[ptr: indptr[f_ind + 1]])
+        nz = n_samples - data.size
+        median[f_ind] = _get_median(data, nz)
 
     return median

sklearn/utils/tests/test_sparsefuncs.py

@@ -389,3 +389,6 @@ def test_csc_row_median():
     X = [[0, -2], [-1, -5], [1, -3]]
     csc = sp.csc_matrix(X)
     assert_array_equal(csc_row_median(csc), np.array([0., -3]))
+
+    # Test that it raises an Error for non-csc matrices.
+    assert_raises(TypeError, csc_row_median, sp.csr_matrix(X))