Update densifying sparse array

Switch from `.A` to `.toarray()`

scvelo/core/_anndata.py

@@ -284,7 +284,7 @@ def get_df(
         df = data
 
     if issparse(df):
-        df = np.array(df.A)
+        df = np.array(df.toarray())
     if columns is None and hasattr(df, "names"):
         columns = df.names
 
@@ -426,7 +426,7 @@ def make_dense(
     for modality in modalities:
         count_data = get_modality(adata=adata, modality=modality)
         if issparse(count_data):
-            set_modality(adata=adata, modality=modality, new_value=count_data.A)
+            set_modality(adata=adata, modality=modality, new_value=count_data.toarray())
 
     return adata if not inplace else None
 

scvelo/core/_linear_models.py

@@ -73,7 +73,10 @@ def _trim_data(self, data: List) -> List:
             data = [data]
 
         data = np.array(
-            [data_mat.A if issparse(data_mat) else data_mat for data_mat in data]
+            [
+                data_mat.toarray() if issparse(data_mat) else data_mat
+                for data_mat in data
+            ]
         )
 
         # TODO: Add explanatory comment

scvelo/inference/_metabolic_labeling.py

@@ -121,7 +121,7 @@ def _get_n_neighbors(
         rep_X = rep_X[rows, cols]
 
         if sparse_op:
-            n_neighbors_to_use = np.cumsum(rep_X.A > 0, axis=1)
+            n_neighbors_to_use = np.cumsum(rep_X.toarray() > 0, axis=1)
         else:
             n_neighbors_to_use = np.cumsum(rep_X > 0, axis=1)
 

scvelo/plotting/heatmap.py

@@ -97,7 +97,7 @@ def heatmap(
         else adata[:, var_names].X
     )
     if issparse(X):
-        X = X.A
+        X = X.toarray()
     df = pd.DataFrame(X[np.argsort(time)], columns=var_names)
 
     if n_convolve is not None:

scvelo/plotting/utils.py

@@ -36,7 +36,7 @@
 def make_dense(X):
     """TODO."""
     if issparse(X):
-        XA = X.A if X.ndim == 2 else X.A1
+        XA = X.toarray() if X.ndim == 2 else X.A1
     else:
         XA = X.A1 if isinstance(X, np.matrix) else X
     return np.array(XA)
@@ -799,7 +799,7 @@ def interpret_colorkey(adata, c=None, layer=None, perc=None, use_raw=None):
                 if adata.raw is None and use_raw:
                     raise ValueError("AnnData object does not have `raw` counts.")
                 c = adata.raw.obs_vector(c) if use_raw else adata.obs_vector(c)
-            c = c.A.flatten() if issparse(c) else c
+            c = c.toarray().flatten() if issparse(c) else c
         elif c in adata.var.keys():  # color by observation key
             c = adata.var[c]
         elif np.any([var_key in c for var_key in adata.var.keys()]):

scvelo/plotting/velocity.py

@@ -169,7 +169,7 @@ def velocity(
         _adata = adata[:, var]
         s, u = _adata.layers[skey], _adata.layers[ukey]
         if issparse(s):
-            s, u = s.A, u.A
+            s, u = s.toarray(), u.toarray()
 
         # spliced/unspliced phase portrait with steady-state estimate
         ax = pl.subplot(gs[v * nplts])

scvelo/plotting/velocity_graph.py

@@ -133,7 +133,7 @@ def velocity_graph(
 
     if groups is not None:
         if issparse(T):
-            T = T.A
+            T = T.toarray()
         T[~groups_to_bool(adata, groups, color)] = 0
         T = csr_matrix(T)
         T.eliminate_zeros()

scvelo/preprocessing/moments.py

@@ -89,12 +89,12 @@ def moments(
         adata.layers["Ms"] = (
             csr_matrix.dot(connectivities, csr_matrix(adata.layers["spliced"]))
             .astype(np.float32)
-            .A
+            .toarray()
         )
         adata.layers["Mu"] = (
             csr_matrix.dot(connectivities, csr_matrix(adata.layers["unspliced"]))
             .astype(np.float32)
-            .A
+            .toarray()
         )
         # if renormalize: normalize_per_cell(adata, layers={'Ms', 'Mu'}, enforce=True)
 
@@ -130,8 +130,8 @@ def second_order_moments(adata, adjusted=False):
     s, u = csr_matrix(adata.layers["spliced"]), csr_matrix(adata.layers["unspliced"])
     if s.shape[0] == 1:
         s, u = s.T, u.T
-    Mss = csr_matrix.dot(connectivities, s.multiply(s)).astype(np.float32).A
-    Mus = csr_matrix.dot(connectivities, s.multiply(u)).astype(np.float32).A
+    Mss = csr_matrix.dot(connectivities, s.multiply(s)).astype(np.float32).toarray()
+    Mus = csr_matrix.dot(connectivities, s.multiply(u)).astype(np.float32).toarray()
     if adjusted:
         Mss = 2 * Mss - adata.layers["Ms"].reshape(Mss.shape)
         Mus = 2 * Mus - adata.layers["Mu"].reshape(Mus.shape)
@@ -157,7 +157,7 @@ def second_order_moments_u(adata):
 
     connectivities = get_connectivities(adata)
     u = csr_matrix(adata.layers["unspliced"])
-    Muu = csr_matrix.dot(connectivities, u.multiply(u)).astype(np.float32).A
+    Muu = csr_matrix.dot(connectivities, u.multiply(u)).astype(np.float32).toarray()
 
     return Muu
 
@@ -222,5 +222,5 @@ def get_moments(
     else:
         Mx = csr_matrix.dot(connectivities, X)
     if issparse(X):
-        Mx = Mx.astype(np.float32).A
+        Mx = Mx.astype(np.float32).toarray()
     return Mx

scvelo/preprocessing/neighbors.py

@@ -326,7 +326,7 @@ def fit(self, X, metric="l2", M=16, ef=100, ef_construction=100, random_state=0)
         ef_c, ef = max(ef_construction, self.n_neighbors), max(self.n_neighbors, ef)
         metric = "l2" if metric == "euclidean" else metric
 
-        X = X.A if issparse(X) else X
+        X = X.toarray() if issparse(X) else X
         ns, dim = X.shape
 
         knn = hnswlib.Index(space=metric, dim=dim)
@@ -564,7 +564,7 @@ def get_duplicate_cells(data):
         vals = [val for val, count in Counter(lst).items() if count > 1]
         idx_dup = np.where(pd.Series(lst).isin(vals))[0]
 
-        X_new = np.array(X[idx_dup].A if issparse(X) else X[idx_dup])
+        X_new = np.array(X[idx_dup].toarray() if issparse(X) else X[idx_dup])
         sorted_idx = np.lexsort(X_new.T)
         sorted_data = X_new[sorted_idx, :]
 

scvelo/tools/optimization.py

@@ -12,10 +12,10 @@
 # TODO: Add docstrings
 def get_weight(x, y=None, perc=95):
     """TODO."""
-    xy_norm = np.array(x.A if issparse(x) else x)
+    xy_norm = np.array(x.toarray() if issparse(x) else x)
     if y is not None:
         if issparse(y):
-            y = y.A
+            y = y.toarray()
         xy_norm = xy_norm / np.clip(np.max(xy_norm, axis=0), 1e-3, None)
         xy_norm += y / np.clip(np.max(y, axis=0), 1e-3, None)
     if isinstance(perc, numbers.Number):
@@ -84,7 +84,7 @@ def optimize_NxN(x, y, fit_offset=False, perc=None):
             perc = perc[1]
         weights = get_weight(x, y, perc).astype(bool)
         if issparse(weights):
-            weights = weights.A
+            weights = weights.toarray()
     else:
         weights = None
 

scvelo/tools/paga.py

@@ -150,7 +150,7 @@ def compute_transitions(self):
         transitions_conf.eliminate_zeros()
 
         # remove non-confident direct paths if more confident indirect path is found.
-        T = transitions_conf.A
+        T = transitions_conf.toarray()
         threshold = max(np.nanmin(np.nanmax(T / (T > 0), axis=0)) - 1e-6, 0.01)
         T *= T > threshold
         for i in range(len(T)):
@@ -169,7 +169,7 @@ def compute_transitions(self):
                     T_tmp[np.where(T_num[:, i])[0][0], i] = T_max
             from scipy.sparse.csgraph import minimum_spanning_tree
 
-            T_tmp = np.abs(minimum_spanning_tree(-T_tmp).A) > 0
+            T_tmp = np.abs(minimum_spanning_tree(-T_tmp).toarray()) > 0
             T = T_tmp * T
 
         transitions_conf = csr_matrix(T)

scvelo/tools/run.py

@@ -56,8 +56,8 @@ def convert_to_adata(vlm, basis=None):
     layers = OrderedDict()
     layers["spliced"] = vlm.S_sz.T if hasattr(vlm, "S_sz") else vlm.S.T
     layers["unspliced"] = vlm.U_sz.T if hasattr(vlm, "U_sz") else vlm.U.T
-    if hasattr(vlm, "A") and (vlm.A.T.shape == layers["spliced"].shape):
-        layers["ambiguous"] = vlm.A.T
+    if hasattr(vlm, "A") and (vlm.toarray().T.shape == layers["spliced"].shape):
+        layers["ambiguous"] = vlm.toarray().T
 
     if hasattr(vlm, "velocity"):
         layers["velocity"] = vlm.velocity.T
@@ -109,12 +109,12 @@ def __init__(self, adata, basis=None):
             self.S = adata.layers["spliced"].T
             self.U = adata.layers["unspliced"].T
             self.S = (
-                np.array(self.S.A, **kwargs)
+                np.array(self.S.toarray(), **kwargs)
                 if issparse(self.S)
                 else np.array(self.S, **kwargs)
             )
             self.U = (
-                np.array(self.U.A, **kwargs)
+                np.array(self.U.toarray(), **kwargs)
                 if issparse(self.U)
                 else np.array(self.U, **kwargs)
             )
@@ -146,7 +146,7 @@ def __init__(self, adata, basis=None):
             if "ambiguous" in adata.layers.keys():
                 self.A = np.array(adata.layers["ambiguous"].T)
                 if issparse(self.A):
-                    self.A = self.A.A
+                    self.A = self.A.toarray()
 
             self.ca = {}
             self.ra = {}

scvelo/tools/terminal_states.py

@@ -57,7 +57,7 @@ def cell_fate(
     T = transition_matrix(_adata, self_transitions=self_transitions)
     fate = np.linalg.inv(np.eye(_adata.n_obs) - T)
     if issparse(T):
-        fate = fate.A
+        fate = fate.toarray()
     cell_fates = np.array(_adata.obs[groupby][fate.argmax(1)])
     if disconnected_groups is not None:
         idx = _adata.obs[groupby].isin(disconnected_groups)
@@ -123,7 +123,7 @@ def cell_origin(
     T = transition_matrix(_adata, self_transitions=self_transitions, backward=True)
     fate = np.linalg.inv(np.eye(_adata.n_obs) - T)
     if issparse(T):
-        fate = fate.A
+        fate = fate.toarray()
     cell_fates = np.array(_adata.obs[groupby][fate.argmax(1)])
     if disconnected_groups is not None:
         idx = _adata.obs[groupby].isin(disconnected_groups)

scvelo/tools/transition_matrix.py

@@ -100,7 +100,7 @@ def transition_matrix(
         graph = graph.multiply(basis_graph)
 
     if self_transitions:
-        confidence = graph.max(1).A.flatten()
+        confidence = graph.max(1).toarray().flatten()
         ub = np.percentile(confidence, 98)
         self_prob = np.clip(ub - confidence, 0, 1)
         graph.setdiag(self_prob)

scvelo/tools/utils.py

@@ -33,7 +33,7 @@ def mean(x, axis=0):
 # TODO: Add docstrings
 def make_dense(X):
     """TODO."""
-    XA = X.A if issparse(X) and X.ndim == 2 else X.A1 if issparse(X) else X
+    XA = X.toarray() if issparse(X) and X.ndim == 2 else X.A1 if issparse(X) else X
     if XA.ndim == 2:
         XA = XA[0] if XA.shape[0] == 1 else XA[:, 0] if XA.shape[1] == 1 else XA
     return np.array(XA)
@@ -327,8 +327,8 @@ def cutoff_small_velocities(
     x = adata.layers["spliced"] if use_raw else adata.layers["Ms"]
     y = adata.layers["unspliced"] if use_raw else adata.layers["Mu"]
 
-    x_max = x.max(0).A[0] if issparse(x) else x.max(0)
-    y_max = y.max(0).A[0] if issparse(y) else y.max(0)
+    x_max = x.max(0).toarray()[0] if issparse(x) else x.max(0)
+    y_max = y.max(0).toarray()[0] if issparse(y) else y.max(0)
 
     xy_norm = x / np.clip(x_max, 1e-3, None) + y / np.clip(y_max, 1e-3, None)
     W = xy_norm >= np.percentile(xy_norm, 98, axis=0) * frac_of_max
@@ -449,9 +449,9 @@ def vcorrcoef(X, y, mode="pearsons", axis=-1):
         Which correlation metric to use.
     """
     if issparse(X):
-        X = np.array(X.A)
+        X = np.array(X.toarray())
     if issparse(y):
-        y = np.array(y.A)
+        y = np.array(y.toarray())
     if axis == 0:
         if X.ndim > 1:
             X = np.array(X.T)

scvelo/tools/velocity_embedding.py

@@ -158,7 +158,7 @@ def velocity_embedding(
         T.eliminate_zeros()
 
         densify = adata.n_obs < 1e4
-        TA = T.A if densify else None
+        TA = T.toarray() if densify else None
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -179,7 +179,7 @@ def velocity_embedding(
             )
             delta = T.dot(X[:, vgenes]) - X[:, vgenes]
             if issparse(delta):
-                delta = delta.A
+                delta = delta.toarray()
             cos_proj = (V * delta).sum(1) / l2_norm(delta)
             V_emb *= np.clip(cos_proj[:, None] * 10, 0, 1)
 

scvelo/tools/velocity_graph.py

@@ -69,12 +69,12 @@ def __init__(
         xkey = xkey if xkey in adata.layers.keys() else "spliced"
 
         X = np.array(
-            adata.layers[xkey].A[:, subset]
+            adata.layers[xkey].toarray()[:, subset]
             if issparse(adata.layers[xkey])
             else adata.layers[xkey][:, subset]
         )
         V = np.array(
-            adata.layers[vkey].A[:, subset]
+            adata.layers[vkey].toarray()[:, subset]
             if issparse(adata.layers[vkey])
             else adata.layers[vkey][:, subset]
         )
@@ -209,7 +209,7 @@ def compute_cosines(
             )
             self.uncertainties.eliminate_zeros()
 
-        confidence = self.graph.max(1).A.flatten()
+        confidence = self.graph.max(1).toarray().flatten()
         self.self_prob = np.clip(np.percentile(confidence, 98) - confidence, 0, 1)
 
     def _compute_cosines(self, obs_idx, queue):

tests/core/test_anndata.py

@@ -126,9 +126,9 @@ def test_cleanup_all(
 
         if dense:
             if layer is None:
-                adata.X = adata.X.A
+                adata.X = adata.X.toarray()
             else:
-                adata.layers[layer] = adata.layers[layer].A
+                adata.layers[layer] = adata.layers[layer].toarray()
         returned_adata = cleanup(adata=adata, clean="all", inplace=inplace)
 
         if not inplace:

tests/preprocessing/test_moments.py

@@ -42,9 +42,9 @@ def test_first_moments(
 
         if dense:
             if layer is None:
-                adata.X = adata.X.A
+                adata.X = adata.X.toarray()
             else:
-                adata.layers[layer] = adata.layers[layer].A
+                adata.layers[layer] = adata.layers[layer].toarray()
 
         first_order_moment = get_moments(adata=adata, layer=layer, mode=mode)
         assert isinstance(first_order_moment, np.ndarray)
@@ -69,9 +69,9 @@ def test_second_moments(
 
         if dense:
             if layer is None:
-                adata.X = adata.X.A
+                adata.X = adata.X.toarray()
             else:
-                adata.layers[layer] = adata.layers[layer].A
+                adata.layers[layer] = adata.layers[layer].toarray()
 
         second_order_moment = get_moments(
             adata=adata, layer=layer, mode=mode, second_order=True, centered=False
@@ -98,9 +98,9 @@ def test_passing_array_for_layer(
 
         if dense:
             if layer is None:
-                adata.X = adata.X.A
+                adata.X = adata.X.toarray()
             else:
-                adata.layers[layer] = adata.layers[layer].A
+                adata.layers[layer] = adata.layers[layer].toarray()
 
         if layer is None:
             first_order_moment = get_moments(adata=adata, layer=adata.X, mode=mode)
@@ -181,13 +181,15 @@ def _compare_adatas(self, adata_1, adata_2):
         assert set(adata_1.obsp) == {"distances", "connectivities"}
         assert issparse(adata_1.obsp["connectivities"])
         np.testing.assert_almost_equal(
-            adata_1.obsp["connectivities"].A,
-            adata_2.obsp["connectivities"].A,
+            adata_1.obsp["connectivities"].toarray(),
+            adata_2.obsp["connectivities"].toarray(),
             decimal=4,
         )
         assert issparse(adata_1.obsp["distances"])
         np.testing.assert_almost_equal(
-            adata_1.obsp["distances"].A, adata_2.obsp["distances"].A, decimal=3
+            adata_1.obsp["distances"].toarray(),
+            adata_2.obsp["distances"].toarray(),
+            decimal=3,
         )
 
         # Check `.uns` is unchanged