Merge pull request scikit-learn#3169 from mjbommar/issue-3167-eradicate-todense

PR re: issue 3167 to eradicate .todense()

Author: ogrisel

examples/applications/plot_model_complexity_influence.py

@@ -119,7 +119,7 @@ def plot_influence(conf, mse_values, prediction_times, complexities):
 
 
 def _count_nonzero_coefficients(estimator):
-    a = estimator.coef_.todense()
+    a = estimator.coef_.toarray()
     return np.count_nonzero(a)
 
 ###############################################################################

examples/linear_model/lasso_dense_vs_sparse_data.py

@@ -59,7 +59,7 @@
 print("Sparse Lasso done in %fs" % (time() - t0))
 
 t0 = time()
-dense_lasso.fit(Xs.todense(), y)
+dense_lasso.fit(Xs.toarray(), y)
 print("Dense Lasso done in %fs" % (time() - t0))
 
 print("Distance between coefficients : %s"

sklearn/cluster/bicluster/tests/test_utils.py

@@ -35,11 +35,11 @@ def test_get_submatrix():
     for X in (data, csr_matrix(data)):
         submatrix = get_submatrix(rows, cols, X)
         if issparse(submatrix):
-            submatrix = submatrix.todense()
+            submatrix = submatrix.toarray()
         assert_array_equal(submatrix, [[2, 3],
                                        [6, 7],
                                        [18, 19]])
         submatrix[:] = -1
         if issparse(X):
-            X = X.todense()
+            X = X.toarray()
         assert_true(np.all(X != -1))

sklearn/cluster/tests/test_hierarchical.py

@@ -167,15 +167,15 @@ def test_agglomerative_clustering():
         clustering = AgglomerativeClustering(
             n_clusters=10,
             connectivity=sparse.lil_matrix(
-                connectivity.todense()[:10, :10]),
+                connectivity.toarray()[:10, :10]),
             linkage=linkage)
         assert_raises(ValueError, clustering.fit, X)
 
     # Test that using ward with another metric than euclidean raises an
     # exception
     clustering = AgglomerativeClustering(
         n_clusters=10,
-        connectivity=connectivity.todense(),
+        connectivity=connectivity.toarray(),
         affinity="manhattan",
         linkage="ward")
     assert_raises(ValueError, clustering.fit, X)

sklearn/cluster/tests/test_spectral.py

@@ -188,7 +188,7 @@ def test_discretize(seed=8):
                                              y_true)),
                                             shape=(n_samples,
                                                    n_class + 1))
-            y_true_noisy = (y_indicator.todense()
+            y_true_noisy = (y_indicator.toarray()
                             + 0.1 * random_state.randn(n_samples,
                                                        n_class + 1))
             y_pred = discretize(y_true_noisy, random_state)

sklearn/datasets/tests/test_svmlight_format.py

@@ -165,13 +165,13 @@ def test_load_with_qid():
     7 qid:2 1:0.87 2:0.12""")
     X, y = load_svmlight_file(BytesIO(data), query_id=False)
     assert_array_equal(y, [3, 2, 7])
-    assert_array_equal(X.todense(), [[.53, .12], [.13, .1], [.87, .12]])
+    assert_array_equal(X.toarray(), [[.53, .12], [.13, .1], [.87, .12]])
     res1 = load_svmlight_files([BytesIO(data)], query_id=True)
     res2 = load_svmlight_file(BytesIO(data), query_id=True)
     for X, y, qid in (res1, res2):
         assert_array_equal(y, [3, 2, 7])
         assert_array_equal(qid, [1, 1, 2])
-        assert_array_equal(X.todense(), [[.53, .12], [.13, .1], [.87, .12]])
+        assert_array_equal(X.toarray(), [[.53, .12], [.13, .1], [.87, .12]])
 
 
 @raises(ValueError)

sklearn/decomposition/tests/test_pca.py

@@ -248,7 +248,7 @@ def test_sparse_randomized_pca_inverse():
     Y = pca.transform(X)
 
     Y_inverse = pca.inverse_transform(Y)
-    assert_almost_equal(X.todense(), Y_inverse, decimal=2)
+    assert_almost_equal(X.toarray(), Y_inverse, decimal=2)
 
     # same as above with whitening (approximate reconstruction)
     pca = assert_warns(DeprecationWarning, RandomizedPCA(n_components=2,

sklearn/feature_extraction/image.py

@@ -124,7 +124,7 @@ def _to_graph(n_x, n_y, n_z, mask=None, img=None,
                               (n_voxels, n_voxels),
                               dtype=dtype)
     if return_as is np.ndarray:
-        return graph.todense()
+        return graph.toarray()
     return return_as(graph)
 
 

sklearn/feature_selection/tests/test_base.py

@@ -62,8 +62,8 @@ def test_transform_sparse():
     sel = StepSelector()
     Xt_actual = sel.fit(sparse(X)).transform(sparse(X))
     Xt_actual2 = sel.fit_transform(sparse(X))
-    assert_array_equal(Xt, Xt_actual.todense())
-    assert_array_equal(Xt, Xt_actual2.todense())
+    assert_array_equal(Xt, Xt_actual.toarray())
+    assert_array_equal(Xt, Xt_actual2.toarray())
 
     # Check dtype matches
     assert_equal(np.int32, sel.transform(sparse(X).astype(np.int32)).dtype)
@@ -96,7 +96,7 @@ def test_inverse_transform_sparse():
     sparse = sp.csc_matrix
     sel = StepSelector()
     Xinv_actual = sel.fit(sparse(X)).inverse_transform(sparse(Xt))
-    assert_array_equal(Xinv, Xinv_actual.todense())
+    assert_array_equal(Xinv, Xinv_actual.toarray())
 
     # Check dtype matches
     assert_equal(np.int32,

sklearn/linear_model/tests/test_sparse_coordinate_descent.py

@@ -20,7 +20,7 @@ def test_sparse_coef():
     clf.coef_ = [1, 2, 3]
 
     assert_true(sp.isspmatrix(clf.sparse_coef_))
-    assert_equal(clf.sparse_coef_.todense().tolist()[0], clf.coef_)
+    assert_equal(clf.sparse_coef_.toarray().tolist()[0], clf.coef_)
 
 
 def test_normalize_option():
@@ -168,7 +168,7 @@ def _test_sparse_enet_not_as_toy_dataset(alpha, fit_intercept, positive):
     d_clf = ElasticNet(alpha=alpha, l1_ratio=0.8, fit_intercept=fit_intercept,
                        max_iter=max_iter, tol=1e-7, positive=positive,
                        warm_start=True)
-    d_clf.fit(X_train.todense(), y_train)
+    d_clf.fit(X_train.toarray(), y_train)
 
     assert_almost_equal(d_clf.dual_gap_, 0, 4)
     assert_greater(d_clf.score(X_test, y_test), 0.85)
@@ -207,7 +207,7 @@ def test_sparse_lasso_not_as_toy_dataset():
 
     # check the convergence is the same as the dense version
     d_clf = Lasso(alpha=0.1, fit_intercept=False, max_iter=max_iter, tol=1e-7)
-    d_clf.fit(X_train.todense(), y_train)
+    d_clf.fit(X_train.toarray(), y_train)
     assert_almost_equal(d_clf.dual_gap_, 0, 4)
     assert_greater(d_clf.score(X_test, y_test), 0.85)
 
@@ -254,7 +254,7 @@ def test_same_output_sparse_dense_lasso_and_enet_cv():
         clfs = ElasticNetCV(max_iter=100, cv=5, normalize=normalize)
         ignore_warnings(clfs.fit)(X, y)
         clfd = ElasticNetCV(max_iter=100, cv=5, normalize=normalize)
-        ignore_warnings(clfd.fit)(X.todense(), y)
+        ignore_warnings(clfd.fit)(X.toarray(), y)
         assert_almost_equal(clfs.alpha_, clfd.alpha_, 7)
         assert_almost_equal(clfs.intercept_, clfd.intercept_, 7)
         assert_array_almost_equal(clfs.mse_path_, clfd.mse_path_)
@@ -263,7 +263,7 @@ def test_same_output_sparse_dense_lasso_and_enet_cv():
         clfs = LassoCV(max_iter=100, cv=4, normalize=normalize)
         ignore_warnings(clfs.fit)(X, y)
         clfd = LassoCV(max_iter=100, cv=4, normalize=normalize)
-        ignore_warnings(clfd.fit)(X.todense(), y)
+        ignore_warnings(clfd.fit)(X.toarray(), y)
         assert_almost_equal(clfs.alpha_, clfd.alpha_, 7)
         assert_almost_equal(clfs.intercept_, clfd.intercept_, 7)
         assert_array_almost_equal(clfs.mse_path_, clfd.mse_path_)