anndata et scanpy

anndata

package qui permet de stocker des matrices annotées

Définition d'un objet :

values = numpy.random.normal(1, size = (100, 200)).astype(numpy.float32); adata = anndata.AnnData(values)
les variables sont en colonnes, les observations en lignes (comme un dataframe pandas).
adata.n_vars : le nombre de variables.
adata.n_obs : le nombre d'observations.
adata.shape : paire nombre de lignes (observations), nombre de colonnes (variables).
adata.X : la matrice des observations
on peut donner des noms aux observations : adata.obs_names = ['cell' + str(i) for i in range(100)]
on peut donner des noms aux variables : adata.var_names = ['gene' + str(i) for i in range(200)]

Metadata :

on peut rajouter des metadata sur les variables (colonnes) et les observations (lignes)
attaché à l'objet, on a 2 dataframes de metadata : adata.obs pour les observations, adata.var pour les variables. Ils sont initialement vides.
adata.obs['cellType'] = ['typeA' if i < 50 else 'typeB' for i in range(100)] : rajout d'une colonne au dataframe adata.obs
si c'est une variable de type catégorie, faire plutôt : adata.obs['cellType'] = pandas.Categorical(['typeA' if i < 50 else 'typeB' for i in range(100)])
on peut aussi rajouter des metadata avec plusieurs dimensions :
- adata.obsm['umap'] = numpy.zeros((100, 2)) : la première dimension de la matrice doit être égale au nombre d'observations.
- adata.varm['geneProp'] = numpy.zeros((200, 5)) : la première dimension de la matrice doit être égale au nombre de variables.
on peut rajouter aussi des informations générales dans le champ uns (unstructured) : adata.uns['info'] = {'a': 1, 'b': 3} (les valeurs peuvent être de n'importe quel type.
var_keys(), obs_keys(), varm_keys(), obsm_keys, uns_keys() : méthodes qui retournent les clefs des différents champs.
on peut rajouter aussi des layers qui doivent avoir les mêmes dimensions que la matrice principale : adata.layers['logTransf'] = numpy.log10(adata.X). Ce sont des array numpy.
adata.layers.keys() : les noms des layers
adata.layers['logTransf'] : pour accéder à une layer avec le nom donné.
adata.layers['logTransf'][:, ['CD8', 'CD25']] : pour accéder à certaines valeurs.

Manipulation :

adata[0:5, 0:3] : subsetting avec les index.
adata[[0, 1], [0, 2]] : subsetting avec les index.
adata[['cell0', 'cell1'], ['gene0', 'gene2']] : subsetting grâce aux noms donnés.
adata[adata.obs.cellType == 'typeA'] : subsetting grâce aux metadata.
quand on fait un subsetting d'un objet AnnData, ça crée seulement une vue sur l'objet existant, pas de nouvelle création.
si on veut créer un objet indépendant, il faut faire une copie : adata2 = adata.copy()
adata.to_df() : renvoie un dataframe de la matrice.
adata.to_df(layer = 'logTransf') : renvoie un dataframe d'une autre layer que la principale.
adata.transpose() : transpose tout l'objet.
adata.chunk_X() : renvoie un sample aléatoire (mais reproductible) de adata.X (1000 lignes et colonnes par défaut).

Sauvegarde dans un fichier :

adata.write('myFile.h5ad', compression = 'gzip') (= adata.write_h5ad) : sauvegarde dans un fichier HDF5
adata = anndata.read('myFile.h5ad') (= anndata.read_h5ad) : pour relire le fichier.
on peut lire le fichier partiellement avec adata = anndata.read('myFile.h5ad', backed = 'r'). L'objet mémorise alors son fichier associé (avec adata.filename) et il faut le fermer quand on a fini : adata.file.close()
adata.write_csvs('myDir', skip_data = False, sep = '\t') : écrit dans myDir toutes les données au format csv avec une tabulation comme séparateur (par défaut, skip_data = False, et il n'écrit pas la matrice). Les noms des fichiers sont les noms des champs : X.csv, obs.csv, var.csv, uns.csv, ...

Concatenation d'objets selon les observations : adata = anndata.AnnData.concatenate(adata1, adata2, , adata3, batch_categories = ['a', 'b', 'c']) :

adata.obs a une colonne batch avec la valeur indiquée.
les noms des observations sont suffixés par le nom de leur batch (ici, en rajoutant -a, -b ou -c selon le batch).

scanpy

Pré-processing :

scanpy.pp.log1p(adata) : normalise les données en prenant le log(x + 1).
- par défaut, l'objet est modifié en place
- si on passe copy = True), ne modifie pas l'objet, mais retourne une copie modifiée.
- scanpy.pp.log1p(adata, layer = 'normalized') : normalise les données de la layer indiquée qui doit avoit été crée avant (permet de conserver les données d'origine dans l'objet)
scanpy.pp.scale(adata) : calcule les données normalisées pour avoir une moyenne 0 et écart-type de 1 pour chaque variable. si copy = False (défaut), rajoute dans adata.var les clefs : mean et std
scanpy.pp.pca(adata) : fait une PCA (par défaut, 50 dimensions) et rajoute les champs suivants :
- adata.osbm['X_pca'] : une array nobs x nbr dimensions de la PCA avec les coordonnées des observations sur les axes.
- adata.varm['PCs'] : les loadings.
- adata.uns['pca']['variance'] : les variances le long de chaque axe.
- adata.uns['pca']['variance_ratio'] : le ratio de chaque variance de chaque axe par rapport à leur somme (la somme des ratios vaut 1).
scanpy.pp.neighbors(adata) : calcule le graphe des plus proches voisins. On peut donner :
- n_neighbors : le nombre de voisins (défaut = 15).
- n_pcs : le nombre d'axes principaux à utiliser.
la fonction rajoute les champs suivants :
- adata.obsp['distances'] : la matrice des distances entre les observations (c'est une matrice sparse)
- adata.obsp['connectivities'] : la matrice d'adjacence du graphe avec les connectivités comme poids.
- adata.uns['neighbors'] : les paramètres d'appel de la fonction.

Processing :

scanpy.tl.pca(adata) : fait de la PCA, comme scanpy.pp.pca.
scanpy.tl.umap(adata) : fait une projection UMAP et rajoute le champs suivant :
- adata.obsm['X_umap'] : les coordonnées UMAP des observations.
scanpy.tl.tsne(adata) : fait une projection tSNE et rajoute le champs suivant :
- adata.obsm['X_tsne] : les coordonnées tSNE des observations.
scanpy.tl.louvain(adata) : fait un clustering de Louvain. Paramètres :
- resolution : règle le nombre de cluster (défaut vaut 1, le nombre de cluster augmente avec la resolution.
cela rajoute les champs suivants :
- adata.obs['louvain'] : numéro du cluster pour chaque observation.
- adata.uns['louvain'] : les paramètres utilisés.

Graphes :

scanpy.pl.pca_variance_ratio(adata) : graphe avec le pourcentage de variance explique pour chaque axe.
scanpy.pl.violin(adata, keys = ['CD4', 'CD8'], groupby = 'sampleName', log = True)
scanpy.pl.umap(adata)

programmer en python, tutoriel python, graphes en python, Aymeric Duclert