anndata.AnnData.concatenate

anndata.AnnData.concatenate#

AnnData.concatenate(*adatas, join='inner', batch_key='batch', batch_categories=None, uns_merge=None, index_unique='-', fill_value=None)[source]#

沿着观测轴连接。

属性 uns、varm 和 obsm 被忽略。

目前，这仅在 'memory' 模式下工作。

注意

有关更灵活和高效的连接，请参阅： concat()。

NoneNone

Parameters:

adatas AnnData

要连接的 AnnData 矩阵。每个矩阵被称为“批次”。

join str (default: 'inner')

使用变量的交集 ('inner') 或并集 ('outer')。

batch_key str (default: 'batch')

使用此键将批量注释添加到 obs。

batch_categories Sequence[Any] (default: None)

将这些用作批量注释的类别。默认情况下，使用递增的数字。

uns_merge str | None (default: None)

用于合并未指定条目的策略。这些策略是递归应用的。目前实现的策略包括：

None: 默认值。连接的对象将只为 uns 拥有一个空字典。
"same": 仅保留在所有 AnnData 对象中具有相同值的条目。
"unique": 仅保留在所有 AnnData 对象中具有唯一值的条目。
"first": 使用第一个非缺失值。
"only": 如果只有一个 AnnData 对象在此路径下有值，则包括该值。

index_unique str | None (default: '-')

通过将现有索引名称与批次类别连接来使索引唯一，例如使用 index_unique='-'。提供 None 以保留现有索引。

fill_value default: None

标量值，用于填充数组中新增的缺失值。注意：仅适用于数组和稀疏矩阵（而不是数据框），并且仅在 join="outer" 时使用。

注意

如果未提供，稀疏矩阵的默认值为 0，numpy 数组的默认值为 np.nan。有关更多信息，请参见下面的示例。

Return type:

AnnData

Returns:

AnnData 连接的AnnData，其中adata.obs[batch_key] 存储一个分类变量，用于标记批次。

注意事项

警告

如果你使用 join='outer'，当批次中缺少变量时，这会用0填充稀疏数据。小心使用。密集数据则用 NaN 填充。请参见示例。

NoneNone

示例

在变量的交叉处连接。

>>> adata1 = AnnData(
...     np.array([[1, 2, 3], [4, 5, 6]]),
...     dict(obs_names=['s1', 's2'], anno1=['c1', 'c2']),
...     dict(var_names=['a', 'b', 'c'], annoA=[0, 1, 2]),
... )
>>> adata2 = AnnData(
...     np.array([[1, 2, 3], [4, 5, 6]]),
...     dict(obs_names=['s3', 's4'], anno1=['c3', 'c4']),
...     dict(var_names=['d', 'c', 'b'], annoA=[0, 1, 2]),
... )
>>> adata3 = AnnData(
...     np.array([[1, 2, 3], [4, 5, 6]]),
...     dict(obs_names=['s1', 's2'], anno2=['d3', 'd4']),
...     dict(var_names=['d', 'c', 'b'], annoA=[0, 2, 3], annoB=[0, 1, 2]),
... )
>>> adata = adata1.concatenate(adata2, adata3)
>>> adata
AnnData object with n_obs × n_vars = 6 × 2
    obs: 'anno1', 'anno2', 'batch'
    var: 'annoA-0', 'annoA-1', 'annoA-2', 'annoB-2'
>>> adata.X
array([[2, 3],
       [5, 6],
       [3, 2],
       [6, 5],
       [3, 2],
       [6, 5]])
>>> adata.obs
     anno1 anno2 batch
s1-0    c1   NaN     0
s2-0    c2   NaN     0
s3-1    c3   NaN     1
s4-1    c4   NaN     1
s1-2   NaN    d3     2
s2-2   NaN    d4     2
>>> adata.var.T
         b  c
annoA-0  1  2
annoA-1  2  1
annoA-2  3  2
annoB-2  2  1

在变量的并集上连接。

>>> outer = adata1.concatenate(adata2, adata3, join='outer')
>>> outer
AnnData object with n_obs × n_vars = 6 × 4
    obs: 'anno1', 'anno2', 'batch'
    var: 'annoA-0', 'annoA-1', 'annoA-2', 'annoB-2'
>>> outer.var.T
           a    b    c    d
annoA-0  0.0  1.0  2.0  NaN
annoA-1  NaN  2.0  1.0  0.0
annoA-2  NaN  3.0  2.0  0.0
annoB-2  NaN  2.0  1.0  0.0
>>> outer.var_names
Index(['a', 'b', 'c', 'd'], dtype='object')
>>> outer.X
array([[ 1.,  2.,  3., nan],
       [ 4.,  5.,  6., nan],
       [nan,  3.,  2.,  1.],
       [nan,  6.,  5.,  4.],
       [nan,  3.,  2.,  1.],
       [nan,  6.,  5.,  4.]])
>>> outer.X.sum(axis=0)
array([nan, 25., 23., nan])
>>> import pandas as pd
>>> Xdf = pd.DataFrame(outer.X, columns=outer.var_names)
>>> Xdf
     a    b    c    d
0  1.0  2.0  3.0  NaN
1  4.0  5.0  6.0  NaN
2  NaN  3.0  2.0  1.0
3  NaN  6.0  5.0  4.0
4  NaN  3.0  2.0  1.0
5  NaN  6.0  5.0  4.0
>>> Xdf.sum()
a     5.0
b    25.0
c    23.0
d    10.0
dtype: float64

处理缺失值的一种方法是使用掩码数组：

>>> from numpy import ma
>>> outer.X = ma.masked_invalid(outer.X)
>>> outer.X
masked_array(
  data=[[1.0, 2.0, 3.0, --],
        [4.0, 5.0, 6.0, --],
        [--, 3.0, 2.0, 1.0],
        [--, 6.0, 5.0, 4.0],
        [--, 3.0, 2.0, 1.0],
        [--, 6.0, 5.0, 4.0]],
  mask=[[False, False, False,  True],
        [False, False, False,  True],
        [ True, False, False, False],
        [ True, False, False, False],
        [ True, False, False, False],
        [ True, False, False, False]],
  fill_value=1e+20)
>>> outer.X.sum(axis=0).data
array([ 5., 25., 23., 10.])

掩码数组没有保存，必须在保存后重新实例化。

>>> outer.write('./test.h5ad')
>>> from anndata import read_h5ad
>>> outer = read_h5ad('./test.h5ad')
>>> outer.X
array([[ 1.,  2.,  3., nan],
       [ 4.,  5.,  6., nan],
       [nan,  3.,  2.,  1.],
       [nan,  6.,  5.,  4.],
       [nan,  3.,  2.,  1.],
       [nan,  6.,  5.,  4.]])

对于稀疏数据，一切表现相似，除非对于 join='outer' ，将添加零。

>>> from scipy.sparse import csr_matrix
>>> adata1 = AnnData(
...     csr_matrix([[0, 2, 3], [0, 5, 6]], dtype=np.float32),
...     dict(obs_names=['s1', 's2'], anno1=['c1', 'c2']),
...     dict(var_names=['a', 'b', 'c']),
... )
>>> adata2 = AnnData(
...     csr_matrix([[0, 2, 3], [0, 5, 6]], dtype=np.float32),
...     dict(obs_names=['s3', 's4'], anno1=['c3', 'c4']),
...     dict(var_names=['d', 'c', 'b']),
... )
>>> adata3 = AnnData(
... csr_matrix([[1, 2, 0], [0, 5, 6]], dtype=np.float32),
...     dict(obs_names=['s5', 's6'], anno2=['d3', 'd4']),
...     dict(var_names=['d', 'c', 'b']),
... )
>>> adata = adata1.concatenate(adata2, adata3, join='outer')
>>> adata.var_names
Index(['a', 'b', 'c', 'd'], dtype='object')
>>> adata.X.toarray()
array([[0., 2., 3., 0.],
       [0., 5., 6., 0.],
       [0., 3., 2., 0.],
       [0., 6., 5., 0.],
       [0., 0., 2., 1.],
       [0., 6., 5., 0.]], dtype=float32)

anndata.AnnData.concatenate

目录

anndata.AnnData.concatenate#