Added tests, increased coverage.

untom · untom · commit 0a47b768444b · 2013-11-06T23:36:08.000+01:00
diff --git a/sklearn/preprocessing/data.py b/sklearn/preprocessing/data.py
@@ -86,7 +86,7 @@ def __init__(self, copy=True, with_centering=True, with_scaling=True,
 
     def _check_array(self, X, copy):
         """Makes sure centering is not enabled for sparse matrices."""
-        X = check_arrays(X, copy=copy, sparse_format="csr")[0]
+        X = check_arrays(X, copy=copy)[0]
         if warn_if_not_float(X, estimator=self):
             X = X.astype(np.float)
         if sparse.issparse(X):
@@ -152,11 +152,6 @@ def inverse_transform(self, X, copy=None):
         copy = copy if copy is not None else self.copy
         X = self._check_array(X, copy)
         if sparse.issparse(X):
-            if not sparse.isspmatrix_csr(X) and not sparse.isspmatrix_csc(X):
-                X = X.tocsr()
-                copy = False
-            if copy:
-                X = X.copy()
             if self.with_scaling:
                 if isinstance(X, sparse.csr_matrix):
                     inplace_csr_column_scale(X, self.scale_)
diff --git a/sklearn/preprocessing/tests/test_data.py b/sklearn/preprocessing/tests/test_data.py
@@ -118,6 +118,30 @@ def test_scaler_2d_arrays():
     assert_true(X_scaled is not X)
 
 
+def test_standard_scaler_zero_variance_features():
+    """Check min max scaler on toy data with zero variance features"""
+    X = [[0., 1., +0.5],
+         [0., 1., -0.1],
+         [0., 1., +1.1]]
+    scaler = StandardScaler()
+    X_trans = scaler.fit_transform(X)
+    X_expected = [[0., 0.,  0.],
+                  [0., 0., -1.22474487],
+                  [0., 0.,  1.22474487]]
+    assert_array_almost_equal(X_trans, X_expected)
+    X_trans_inv = scaler.inverse_transform(X_trans)
+    assert_array_almost_equal(X, X_trans_inv, decimal=4)
+
+    X_new = [[+0., 2., 0.5],
+             [-1., 1., 0.0],
+             [+0., 1., 1.5]]
+    X_trans_new = scaler.transform(X_new)
+    X_expected_new = [[+0., 1.,  0.],
+                      [-1., 0., -1.02062073],
+                      [+0., 0.,  2.04124145]]
+    assert_array_almost_equal(X_trans_new, X_expected_new, decimal=4)
+
+
 def test_min_max_scaler_iris():
     X = iris.data
     scaler = MinMaxScaler()
@@ -761,8 +785,8 @@ def test_robust_scaler_1d():
     assert_array_almost_equal(np.median(X_scaled, axis=0), 0.0)
 
 
-def test_scaler_2d_arrays():
-    """Test scaling of 2d array along first axis"""
+def test_robust_scaler_2d_arrays():
+    """Test robust scaling of 2d array along first axis"""
     rng = np.random.RandomState(0)
     X = rng.randn(4, 5)
     X[:, 0] = 0.0  # first feature is always of zero
@@ -855,6 +879,12 @@ def test_robust_scaler_zero_variance_features():
     X_trans_inv = scaler.inverse_transform(X_trans)
     assert_array_almost_equal(X, X_trans_inv)
 
+    X_trans_new = scaler.transform(X_new)
+    X_expected_new = [[+0., 1., +0.],
+                      [-1., 0., -0.52083],
+                      [+0., 0., +1.04166]]
+    assert_array_almost_equal(X_trans_new, X_expected_new, decimal=3)
+
 
 def test_robust_scaler_int():
     # test that scaler converts integer input to floating
@@ -976,36 +1006,6 @@ def test_maxabs_scaler_zero_variance_features():
     assert_array_almost_equal(X_trans_new, X_expected_new, decimal=2)
 
 
-def test_maxabs_scaler_zero_variance_features():
-    """Check MaxAbsScaler on toy data with zero variance features"""
-    X = [[0., 1., +0.5],
-         [0., 1., -0.3],
-         [0., 1., +1.5],
-         [0., 0., +0.0]]
-
-    X_new = [[+0., 2., 0.5],
-             [-1., 1., 0.0],
-             [+0., 1., 1.5]]
-
-    # default params
-    scaler = MaxAbsScaler()
-    X_trans = scaler.fit_transform(X)
-    X_expected = [[0., 1., 1.0 / 3.0],
-                  [0., 1., -0.2],
-                  [0., 1., 1.0],
-                  [0., 0., 0.0]]
-    assert_array_almost_equal(X_trans, X_expected)
-    X_trans_inv = scaler.inverse_transform(X_trans)
-    assert_array_almost_equal(X, X_trans_inv)
-
-    X_trans_new = scaler.transform(X_new)
-    X_expected_new = [[+0., 2.0, 1.0 / 3.0],
-                      [-1., 1.0, 0.0],
-                      [+0., 1.0, 1.0]]
-
-    assert_array_almost_equal(X_trans_new, X_expected_new, decimal=2)
-
-
 def test_maxabs_scaler_sparse_1D():
     rng = np.random.RandomState(42)
     A = rng.randn(40)
@@ -1026,11 +1026,6 @@ def test_maxabs_scaler_sparse_data():
          [0., 1., -1.5, 0],
          [0., 0., +0.0, -2]]
 
-    X_expected = [[0., 1., 1.0 / 3.0, -0.5],
-                  [0., 1., -0.2,      -0.25],
-                  [0., 1., -1.0,       0.0],
-                  [0., 0.,  0.0,      -1.0]]
-
     X_csr = sparse.csr_matrix(X)
     X_csc = sparse.csc_matrix(X)
 
@@ -1057,7 +1052,6 @@ def test_maxabs_scaler_large_negative_value():
          [0., 1., -100.0,  0.0],
          [0., 0.,   +0.0, -2.0]]
 
-    # default params
     scaler = MaxAbsScaler()
     X_trans = scaler.fit_transform(X)
     X_expected = [[0., 1.,  0.005,    -0.5],
@@ -1076,7 +1070,7 @@ def test_center_property():
          [0., 0.5, -1.4]]
 
     scaler = StandardScaler()
-    X_trans = scaler.fit_transform(X)
+    scaler.fit_transform(X)
     means = [0.0, 0.5, -0.4]
     assert_array_almost_equal(scaler.center_, means)
     assert_array_almost_equal(scaler.mean_, means)  # deprecated parameter
@@ -1089,7 +1083,26 @@ def test_scale_property():
          [0., 4.0, -1.7]]
 
     scaler = StandardScaler()
-    X_trans = scaler.fit_transform(X)
-    means = [1.0, 1.632993, 0.90921211]
-    assert_array_almost_equal(scaler.scale_, means)
-    assert_array_almost_equal(scaler.std_, means)  # deprecated parameter
+    scaler.fit_transform(X)
+    std = [1.0, 1.632993, 0.90921211]
+    assert_array_almost_equal(scaler.scale_, std)
+    assert_array_almost_equal(scaler.std_, std)  # deprecated parameter
+
+
+def test_throws_exceptions_on_unallowed_sparse():
+    """Check that the Scalers throw on unallowed matrix formats."""
+    X = [[0., 2.0, +0.5],
+         [0., 0.0, -0.3],
+         [0., 4.0, -1.7]]
+    X_dia = sparse.dia_matrix(X)
+
+    for Scaler in (MinMaxScaler, RobustScaler):
+        scaler = MinMaxScaler()
+        assert_raises(TypeError, scaler.fit, X_dia)
+        scaler.fit(X)
+        did_raise = False
+        try:
+            scaler.transform(X_dia)
+        except ValueError:
+            did_raise = True
+        assert(did_raise)
