Scanpy : Analyse de cellules individuelles

Vue d'ensemble

Scanpy est une boîte à outils Python scalable pour analyser des données RNA-seq de cellules individuelles, construite sur AnnData. Utilisez cette skill pour des workflows complets de cellules individuelles incluant le contrôle qualité, la normalisation, la réduction de dimensionnalité, le clustering, l'identification de gènes marqueurs, la visualisation et l'analyse de trajectoire.

Quand utiliser cette skill

Cette skill doit être utilisée quand :

Analyser des données RNA-seq de cellules individuelles (formats .h5ad, 10X, CSV)
Effectuer le contrôle qualité sur des datasets scRNA-seq
Créer des visualisations UMAP, t-SNE ou PCA
Identifier les clusters cellulaires et trouver des gènes marqueurs
Annoter les types cellulaires basés sur l'expression génique
Conduire une inférence de trajectoire ou une analyse pseudotemps
Générer des graphiques de cellules individuelles de qualité publication

Démarrage rapide

Import et configuration basiques

import scanpy as sc
import pandas as pd
import numpy as np

# Configurer les paramètres
sc.settings.verbosity = 3
sc.settings.set_figure_params(dpi=80, facecolor='white')
sc.settings.figdir = './figures/'

Charger les données

# Depuis 10X Genomics
adata = sc.read_10x_mtx('path/to/data/')
adata = sc.read_10x_h5('path/to/data.h5')

# Depuis h5ad (format AnnData)
adata = sc.read_h5ad('path/to/data.h5ad')

# Depuis CSV
adata = sc.read_csv('path/to/data.csv')

Comprendre la structure AnnData

L'objet AnnData est la structure de données centrale dans scanpy :

adata.X          # Matrice d'expression (cellules × gènes)
adata.obs        # Métadonnées des cellules (DataFrame)
adata.var        # Métadonnées des gènes (DataFrame)
adata.uns        # Annotations non structurées (dict)
adata.obsm       # Données cellulaires multi-dimensionnelles (PCA, UMAP)
adata.raw        # Sauvegarde des données brutes

# Accéder aux noms des cellules et gènes
adata.obs_names  # Code-barres des cellules
adata.var_names  # Noms des gènes

Workflow d'analyse standard

1. Contrôle qualité

Identifier et filtrer les cellules et gènes de faible qualité :

# Identifier les gènes mitochondriaux
adata.var['mt'] = adata.var_names.str.startswith('MT-')

# Calculer les métriques QC
sc.pp.calculate_qc_metrics(adata, qc_vars=['mt'], inplace=True)

# Visualiser les métriques QC
sc.pl.violin(adata, ['n_genes_by_counts', 'total_counts', 'pct_counts_mt'],
             jitter=0.4, multi_panel=True)

# Filtrer les cellules et gènes
sc.pp.filter_cells(adata, min_genes=200)
sc.pp.filter_genes(adata, min_cells=3)
adata = adata[adata.obs.pct_counts_mt < 5, :]  # Supprimer les cellules à MT% élevé

Utiliser le script QC pour l'analyse automatisée :

python scripts/qc_analysis.py input_file.h5ad --output filtered.h5ad

2. Normalisation et prétraitement

# Normaliser à 10 000 counts par cellule
sc.pp.normalize_total(adata, target_sum=1e4)

# Transformation log
sc.pp.log1p(adata)

# Sauvegarder les counts bruts pour plus tard
adata.raw = adata

# Identifier les gènes hautement variables
sc.pp.highly_variable_genes(adata, n_top_genes=2000)
sc.pl.highly_variable_genes(adata)

# Sous-ensemble aux gènes hautement variables
adata = adata[:, adata.var.highly_variable]

# Régresser la variation non désirée
sc.pp.regress_out(adata, ['total_counts', 'pct_counts_mt'])

# Mettre à l'échelle les données
sc.pp.scale(adata, max_value=10)

3. Réduction de dimensionnalité

# PCA
sc.tl.pca(adata, svd_solver='arpack')
sc.pl.pca_variance_ratio(adata, log=True)  # Vérifier le graphique coude

# Calculer le graphique de voisinage
sc.pp.neighbors(adata, n_neighbors=10, n_pcs=40)

# UMAP pour la visualisation
sc.tl.umap(adata)
sc.pl.umap(adata, color='leiden')

# Alternative : t-SNE
sc.tl.tsne(adata)

4. Clustering

# Clustering Leiden (recommandé)
sc.tl.leiden(adata, resolution=0.5)
sc.pl.umap(adata, color='leiden', legend_loc='on data')

# Essayer plusieurs résolutions pour trouver la granularité optimale
for res in [0.3, 0.5, 0.8, 1.0]:
    sc.tl.leiden(adata, resolution=res, key_added=f'leiden_{res}')

5. Identification de gènes marqueurs

# Trouver les gènes marqueurs pour chaque cluster
sc.tl.rank_genes_groups(adata, 'leiden', method='wilcoxon')

# Visualiser les résultats
sc.pl.rank_genes_groups(adata, n_genes=25, sharey=False)
sc.pl.rank_genes_groups_heatmap(adata, n_genes=10)
sc.pl.rank_genes_groups_dotplot(adata, n_genes=5)

# Obtenir les résultats sous forme de DataFrame
markers = sc.get.rank_genes_groups_df(adata, group='0')

6. Annotation des types cellulaires

# Définir les gènes marqueurs pour les types cellulaires connus
marker_genes = ['CD3D', 'CD14', 'MS4A1', 'NKG7', 'FCGR3A']

# Visualiser les marqueurs
sc.pl.umap(adata, color=marker_genes, use_raw=True)
sc.pl.dotplot(adata, var_names=marker_genes, groupby='leiden')

# Annotation manuelle
cluster_to_celltype = {
    '0': 'CD4 T cells',
    '1': 'CD14+ Monocytes',
    '2': 'B cells',
    '3': 'CD8 T cells',
}
adata.obs['cell_type'] = adata.obs['leiden'].map(cluster_to_celltype)

# Visualiser les types annotés
sc.pl.umap(adata, color='cell_type', legend_loc='on data')

7. Sauvegarder les résultats

# Sauvegarder les données traitées
adata.write('results/processed_data.h5ad')

# Exporter les métadonnées
adata.obs.to_csv('results/cell_metadata.csv')
adata.var.to_csv('results/gene_metadata.csv')

Tâches courantes

Créer des graphiques de qualité publication

# Définir les valeurs par défaut de haute qualité
sc.settings.set_figure_params(dpi=300, frameon=False, figsize=(5, 5))
sc.settings.file_format_figs = 'pdf'

# UMAP avec style personnalisé
sc.pl.umap(adata, color='cell_type',
           palette='Set2',
           legend_loc='on data',
           legend_fontsize=12,
           legend_fontoutline=2,
           frameon=False,
           save='_publication.pdf')

# Heatmap des gènes marqueurs
sc.pl.heatmap(adata, var_names=genes, groupby='cell_type',
              swap_axes=True, show_gene_labels=True,
              save='_markers.pdf')

# Graphique en points
sc.pl.dotplot(adata, var_names=genes, groupby='cell_type',
              save='_dotplot.pdf')

Consultez references/plotting_guide.md pour des exemples de visualisation complets.

Inférence de trajectoire

# PAGA (Partition-based graph abstraction)
sc.tl.paga(adata, groups='leiden')
sc.pl.paga(adata, color='leiden')

# Pseudotemps de diffusion
adata.uns['iroot'] = np.flatnonzero(adata.obs['leiden'] == '0')[0]
sc.tl.dpt(adata)
sc.pl.umap(adata, color='dpt_pseudotime')

Expression différentielle entre les conditions

# Comparer traité vs contrôle au sein des types cellulaires
adata_subset = adata[adata.obs['cell_type'] == 'T cells']
sc.tl.rank_genes_groups(adata_subset, groupby='condition',
                         groups=['treated'], reference='control')
sc.pl.rank_genes_groups(adata_subset, groups=['treated'])

Scoring d'ensemble de gènes

# Scorer les cellules pour l'expression d'ensemble de gènes
gene_set = ['CD3D', 'CD3E', 'CD3G']
sc.tl.score_genes(adata, gene_set, score_name='T_cell_score')
sc.pl.umap(adata, color='T_cell_score')

Correction de batch

# Correction de batch ComBat
sc.pp.combat(adata, key='batch')

# Alternative : utiliser Harmony ou scVI (packages séparés)

Paramètres clés à ajuster

Contrôle qualité

min_genes : Gènes minimum par cellule (généralement 200-500)
min_cells : Cellules minimum par gène (généralement 3-10)
pct_counts_mt : Seuil mitochondrial (généralement 5-20%)

Normalisation

target_sum : Counts cible par cellule (défaut 1e4)

Sélection de features

n_top_genes : Nombre de HVGs (généralement 2 000-3 000)
min_mean, max_mean, min_disp : Paramètres de sélection HVG

Réduction de dimensionnalité

n_pcs : Nombre de composantes principales (vérifier le graphique de ratio de variance)
n_neighbors : Nombre de voisins (généralement 10-30)

Clustering

resolution : Granularité du clustering (0,4-1,2, plus élevé = plus de clusters)

Pièges courants et bonnes pratiques

Toujours sauvegarder les counts bruts : adata.raw = adata avant de filtrer les gènes
Vérifier attentivement les graphiques QC : Ajuster les seuils en fonction de la qualité du dataset
Utiliser Leiden plutôt que Louvain : Plus efficace et meilleurs résultats
Essayer plusieurs résolutions de clustering : Trouver la granularité optimale
Valider les annotations de types cellulaires : Utiliser plusieurs gènes marqueurs
Utiliser use_raw=True pour les graphiques d'expression génique : Affiche les counts originaux
Vérifier le ratio de variance PCA : Déterminer le nombre optimal de PCs
Sauvegarder les résultats intermédiaires : Les workflows longs peuvent échouer en chemin

Ressources inclusupp

scripts/qc_analysis.py

Script de contrôle qualité automatisé qui calcule les métriques, génère les graphiques et filtre les données :

python scripts/qc_analysis.py input.h5ad --output filtered.h5ad \
    --mt-threshold 5 --min-genes 200 --min-cells 3

references/standard_workflow.md

Workflow complet étape par étape avec explications détaillées et exemples de code pour :

Chargement et configuration des données
Contrôle qualité avec visualisation
Normalisation et mise à l'échelle
Sélection de features
Réduction de dimensionnalité (PCA, UMAP, t-SNE)
Clustering (Leiden, Louvain)
Identification de gènes marqueurs
Annotation des types cellulaires
Inférence de trajectoire
Expression différentielle

Consultez cette référence lors de la réalisation d'une analyse complète à partir de zéro.

references/api_reference.md

Guide de référence rapide des fonctions scanpy organisées par module :

Lecture/écriture de données (sc.read_*, adata.write_*)
Prétraitement (sc.pp.*)
Outils (sc.tl.*)
Graphiques (sc.pl.*)
Structure AnnData et manipulation
Paramètres et utilitaires

À utiliser pour une recherche rapide des signatures de fonctions et des paramètres courants.

references/plotting_guide.md

Guide de visualisation complet incluant :

Graphiques de contrôle qualité
Visualisations de réduction de dimensionnalité
Visualisations de clustering
Graphiques de gènes marqueurs (heatmaps, graphiques en points, graphiques en violon)
Graphiques de trajectoire et pseudotemps
Personnalisation de qualité publication
Figures multi-panneaux
Palettes de couleurs et style

Consultez ceci lors de la création de figures prêtes pour publication.

assets/analysis_template.py

Template d'analyse complet fournissant un workflow complet du chargement des données à l'annotation des types cellulaires. Copiez et personnalisez ce template pour les nouvelles analyses :

cp assets/analysis_template.py my_analysis.py
# Modifier les paramètres et exécuter
python my_analysis.py

Le template inclut toutes les étapes standard avec des paramètres configurables et des commentaires utiles.

Ressources supplémentaires

Documentation officielle scanpy : https://scanpy.readthedocs.io/
Tutoriels scanpy : https://scanpy-tutorials.readthedocs.io/
Écosystème scverse : https://scverse.org/ (outils connexes : squidpy, scvi-tools, cellrank)
Bonnes pratiques : Luecken & Theis (2019) "Current best practices in single-cell RNA-seq"

Conseils pour une analyse efficace

Commencer avec le template : Utiliser assets/analysis_template.py comme point de départ
Exécuter le script QC en premier : Utiliser scripts/qc_analysis.py pour le filtrage initial
Consulter les références selon les besoins : Charger le workflow et les références API dans le contexte
Itérer sur le clustering : Essayer plusieurs résolutions et méthodes de visualisation
Valider biologiquement : Vérifier que les gènes marqueurs correspondent aux types cellulaires attendus
Documenter les paramètres : Enregistrer les seuils QC et les paramètres d'analyse
Sauvegarder les points de contrôle : Écrire les résultats intermédiaires aux étapes clés