scikit-bio

Que fait scikit-bio ?

Vue d'ensemble

scikit-bio est une bibliothèque Python complète pour travailler avec des données biologiques. Appliquez cette compétence pour des analyses bioinformatiques couvrant la manipulation de séquences, l'alignement, la phylogénétique, l'écologie microbienne et les statistiques multivariées.

Quand utiliser cette compétence

Cette compétence doit être utilisée lorsque l'utilisateur :

• Travaille avec des séquences biologiques (ADN, ARN, protéines)
• A besoin de lire/écrire des formats de fichiers biologiques (FASTA, FASTQ, GenBank, Newick, BIOM, etc.)
• Effectue des alignements de séquences ou recherche des motifs
• Construit ou analyse des arbres phylogénétiques
• Calcule des métriques de diversité (diversité alpha/bêta, distances UniFrac)
• Effectue des analyses d'ordination (PCoA, CCA, RDA)
• Exécute des tests statistiques sur des données biologiques/écologiques (PERMANOVA, ANOSIM, Mantel)
• Analyse les données du microbiome ou de l'écologie des communautés
• Travaille avec des encodages de protéines provenant de modèles de langage
• A besoin de manipuler des tableaux de données biologiques

Capacités principales

1. Manipulation de séquences

Travaillez avec des séquences biologiques à l'aide de classes spécialisées pour l'ADN, l'ARN et les protéines.

Opérations clés :

• Lire/écrire des séquences à partir des formats FASTA, FASTQ, GenBank, EMBL
• Découpage, concaténation et recherche de séquences
• Complément inverse, transcription (ADN→ARN) et traduction (ARN→protéine)
• Recherche de motifs et de patrons à l'aide d'expressions régulières
• Calcul de distances (Hamming, basées sur les k-mers)
• Gestion des scores de qualité et des métadonnées des séquences

Patrons courants :

import skbio

# Lire des séquences depuis un fichier
seq = skbio.DNA.read('input.fasta')

# Opérations sur les séquences
rc = seq.reverse_complement()
rna = seq.transcribe()
protein = rna.translate()

# Rechercher des motifs
motif_positions = seq.find_with_regex('ATG[ACGT]{3}')

# Vérifier les propriétés
has_degens = seq.has_degenerates()
seq_no_gaps = seq.degap()

Remarques importantes :

• Utilisez les classes DNA, RNA, Protein pour les séquences grammaticalisées avec validation
• Utilisez la classe Sequence pour les séquences génériques sans restriction d'alphabet
• Les scores de qualité sont automatiquement chargés à partir des fichiers FASTQ dans les métadonnées positionnelles
• Types de métadonnées : niveau séquence (ID, description), positionnel (par base), intervalle (régions/caractéristiques)

2. Alignement de séquences

Effectuez des alignements de séquences par paires et multiples à l'aide du moteur pair_align (introduit dans scikit-bio 0.7.0), un aligneur dynamique polyvalent et efficace.

Capacités clés :

• Alignement global, local et semi-global (extrémités libres configurables) en une seule fonction
• Wrappers pratiques pair_align_nucl (similaire à BLASTN) et pair_align_prot (similaire à BLASTP)
• Score configurable : tuple de correspondance/non-correspondance ou matrice de substitution nommée ; pénalités de gap linéaires ou affines
• Les résultats PairAlignPath portent des chaînes CIGAR et se convertissent en séquences alignées
• Stockage et manipulation d'alignements de séquences multiples avec TabularMSA

Patrons courants :

from skbio import DNA, Protein
from skbio.alignment import pair_align_nucl, pair_align_prot, pair_align, TabularMSA

# Alignement nucléotidique avec les valeurs par défaut de type BLASTN
seq1, seq2 = DNA('ACTACCAGATTACTTACGGATCAGG'), DNA('CGAAACTACTAGATTACGGATCTTA')
aln = pair_align_nucl(seq1, seq2)
aln.score                                  # score d'alignement (float)
path = aln.paths[0]                        # PairAlignPath (repr montre CIGAR)
aligned_seqs = path.to_aligned((seq1, seq2))  # liste de chaînes avec gaps

# Construire un TabularMSA à partir du chemin d'alignement + des séquences originales
msa = TabularMSA.from_path_seqs(path, (seq1, seq2))

# Personnaliser l'algorithme via pair_align (mode par défaut='global')
aln = pair_align(seq1, seq2, mode='local')                       # Smith-Waterman
aln = pair_align(seq1, seq2, sub_score=(2, -3), gap_cost=(5, 2)) # gaps affines
aln = pair_align(seq1, seq2, sub_score='NUC.4.4', gap_cost=3)    # matrice de substitution, gap linéaire

# Alignement de protéines (similaire à BLASTP, BLOSUM62)
aln = pair_align_prot(Protein('HEAGAWGHEE'), Protein('PAWHEAE'))

# Lire un alignement multiple depuis un fichier et résumer
msa = TabularMSA.read('alignment.fasta', constructor=DNA)
consensus = msa.consensus()

Remarques importantes :

• pair_align remplace le wrapper SSW supprimé (local_pairwise_align_ssw, StripedSmithWaterman) et les aligneurs Python purs obsolètes (global_pairwise_align, local_pairwise_align_nucleotide, etc.)
• Le résultat est un PairAlignResult qui se décompresse également en score, paths, matrices (utilisez keep_matrices=True pour conserver la matrice DP)
• sub_score accepte un tuple (match, mismatch) ou un nom de matrice (par exemple, 'NUC.4.4', 'BLOSUM62') ; gap_cost accepte un nombre unique (linéaire) ou un tuple (ouverture, extension) (affine)
• Analysez les chaînes CIGAR externes avec PairAlignPath.from_cigar('1I8M2D5M2I') ; notez un alignement existant avec align_score(...) et construisez une matrice de distance à partir d'un MSA avec align_dists(...)

3. Arbres phylogénétiques

Construisez, manipulez et analysez des arbres phylogénétiques représentant les relations évolutives.

Capacités clés :

• Construction d'arbres à partir de matrices de distance (UPGMA/WPGMA, Neighbor Joining, GME, BME)
• Réarrangement d'arbres par échange de voisins les plus proches (nni)
• Manipulation d'arbres (élagage, ré-enracinement, parcours)
• Calculs de distances (patristique via cophenet, Robinson-Foulds via compare_rfd)
• Visualisation ASCII
• Entrées/sorties au format Newick

Patrons courants :

from skbio import TreeNode
from skbio.tree import nj, upgma, gme, bme, rf_dists

# Lire un arbre depuis un fichier
tree = TreeNode.read('tree.nwk')

# Construire un arbre à partir d'une matrice de distance
tree = nj(distance_matrix)

# Opérations sur les arbres
subtree = tree.shear(['taxon1', 'taxon2', 'taxon3'])
tips = [node for node in tree.tips()]
lca = tree.lca(['taxon1', 'taxon2'])

# Calculer les distances
patristic_dist = tree.find('taxon1').distance(tree.find('taxon2'))
cophenetic_dm = tree.cophenet()           # matrice de distances patristiques entre les feuilles

# Comparer deux arbres (Robinson-Foulds)
rf_distance = tree.compare_rfd(other_tree)
# Distances RF par paires entre plusieurs arbres -> DistanceMatrix
rf_dm = rf_dists([tree, other_tree, third_tree])

Remarques importantes :

• Utilisez nj() pour le neighbor joining (méthode phylogénétique classique)
• Utilisez upgma() pour UPGMA/WPGMA (suppose une horloge moléculaire)
• GME et BME sont très évolutifs pour les grands arbres ; affinez la topologie avec nni()
• cophenet() (anciennement tip_tip_distances) renvoie la matrice de distances patristiques ; compare_rfd() est la méthode de Robinson-Foulds (compare_wrfd/compare_cophenet pour les variantes pondérées/cophénétiques)
• lca() est l'ancêtre commun le plus récent ; lowest_common_ancestor reste comme alias
• Les arbres peuvent être enracinés ou non ; certaines métriques nécessitent un enracinement spécifique

4. Analyse de la diversité

Calculez les métriques de diversité alpha et bêta pour l'écologie microbienne et l'analyse des communautés.

Capacités clés :

• Diversité alpha : richesse (sobs, observed_features, chao1, ace), Shannon, Simpson, nombres de Hill (hill), PD de Faith (faith_pd), PD généralisé (phydiv), équitabilité de Pielou
• Diversité bêta : Bray-Curtis, Jaccard, UniFrac pondéré/non pondéré, distances euclidiennes
• Métriques de diversité phylogénétique (nécessitent un arbre en entrée)
• Rarefaction et sous-échantillonnage
• Intégration avec l'ordination et les tests statistiques

Patrons courants :

from skbio.diversity import alpha_diversity, beta_diversity

# Diversité alpha (les métriques phylogénétiques prennent taxa= pour le mappage nom de feuille)
alpha = alpha_diversity('shannon', counts_matrix, ids=sample_ids)
faith_pd = alpha_diversity('faith_pd', counts_matrix, ids=sample_ids,
                           tree=tree, taxa=feature_ids)

# Diversité bêta
bc_dm = beta_diversity('braycurtis', counts_matrix, ids=sample_ids)
unifrac_dm = beta_diversity('unweighted_unifrac', counts_matrix,
                            ids=sample_ids, tree=tree, taxa=feature_ids)

# Obtenir les métriques disponibles
from skbio.diversity import get_alpha_diversity_metrics
print(get_alpha_diversity_metrics())

Remarques importantes :

• Les comptages doivent être des entiers représentant des abondances, pas des fréquences relatives
• L'argument pour les métriques phylogénétiques est taxa= (renommé de otu_ids dans la version 0.6.0 ; l'ancien nom est un alias obsolète) ; observed_otus est maintenant observed_features (ou sobs)
• counts_matrix peut être toute entrée de type tableau (tableau NumPy, DataFrame pandas/polars, table BIOM ou AnnData) via le système de distribution
• Les métriques phylogénétiques (PD de Faith, UniFrac) nécessitent un arbre et un mappage taxons-vers-feuille
• Utilisez partial_beta_diversity() pour des paires d'échantillons spécifiques, ou block_beta_diversity() pour de grands calculs décomposés en blocs
• La diversité alpha renvoie une pandas.Series, la diversité bêta renvoie une DistanceMatrix

5. Méthodes d'ordination

Réduisez les données biologiques de haute dimension dans des espaces de dimension inférieure visualisables.

Capacités clés :

• PCoA (Analyse en coordonnées principales) à partir de matrices de distance
• CA (Analyse des correspondances) pour les tableaux de contingence
• CCA (Analyse des correspondances canonique) avec contraintes environnementales
• RDA (Analyse de redondance) pour les relations linéaires
• Projection biplot pour l'interprétation des caractéristiques

Patrons courants :

from skbio.stats.ordination import pcoa, cca
import skbio

# PCoA à partir d'une matrice de distance (limiter les dimensions pour les grandes matrices)
pcoa_results = pcoa(distance_matrix, dimensions=3)
pc1 = pcoa_results.samples['PC1']
pc2 = pcoa_results.samples['PC2']

# Nuage de points intégré coloré par une colonne de métadonnées
fig = pcoa_results.plot(sample_metadata, column='bodysite')

# CCA avec variables environnementales
cca_results = cca(species_matrix, environmental_matrix)

# Sauvegarder/charger les résultats d'ordination
pcoa_results.write('ordination.txt')
results = skbio.OrdinationResults.read('ordination.txt')

Remarques importantes :

• PCoA fonctionne avec toute matrice de distance/dissimilarité ; passez dimensions comme un entier (nombre) ou un flottant dans (0, 1] (fraction de variance cumulée à conserver)
• OrdinationResults expose des attributs basés sur pandas : samples, features, eigvals, proportion_explained, biplot_scores, sample_constraints
• CCA révèle les facteurs environnementaux de la composition de la communauté
• OrdinationResults.plot() produit une figure matplotlib ; les résultats s'intègrent également avec seaborn/plotly

6. Tests statistiques

Effectuez des tests d'hypothèses spécifiques aux données écologiques et biologiques.

Capacités clés :

• PERMANOVA : test des différences de groupes à l'aide de matrices de distance
• ANOSIM : test alternatif pour les différences de groupes
• PERMDISP : test de l'homogénéité des dispersions de groupes
• Test de Mantel : corrélation entre matrices de distance
• Bioenv : trouver les variables environnementales corrélées aux distances
• Abondance différentielle : ancom, dirmult_ttest et dirmult_lme (effets mixtes longitudinaux) dans skbio.stats.composition

Patrons courants :

from skbio.stats.distance import permanova, anosim, mantel

# Tester si les groupes diffèrent significativement
permanova_results = permanova(distance_matrix, grouping, permutations=999)
print(f"valeur p : {permanova_results['p-value']}")

# Test ANOSIM
anosim_results = anosim(distance_matrix, grouping, permutations=999)

# Test de Mantel entre deux matrices de distance
mantel_results = mantel(dm1, dm2, method='pearson', permutations=999)
print(f"Corrélation : {mantel_results[0]}, valeur p : {mantel_results[1]}")

# Abondance différentielle sur une table de caractéristiques (comptages bruts recommandés)
from skbio.stats.composition import dirmult_ttest
da = dirmult_ttest(counts_table, grouping, treatment='caseA', reference='control')

Remarques importantes :

• Les tests de permutation fournissent des tests de signification non paramétriques
• Utilisez 999 permutations ou plus pour des valeurs p robustes
• PERMANOVA est sensible aux différences de dispersion ; associez à PERMDISP
• Les tests de Mantel évaluent la corrélation matricielle (par exemple, distance géographique vs génétique)
• Fournissez aux tests d'abondance différentielle des comptages bruts, pas des proportions pré-normalisées, pour préserver l'information de magnitude

7. Entrées/sorties de fichiers et conversion de format

Lisez et écrivez 19 formats de fichiers biologiques et plus avec une détection automatique de format.

Formats pris en charge :

• Séquences : FASTA, FASTQ, GenBank, EMBL, QSeq
• Alignements : Clustal, PHYLIP, Stockholm
• Arbres : Newick
• Tableaux : BIOM (HDF5 et JSON)
• Distances : matrices carrées délimitées
• Analyse : BLAST+6/7, GFF3, résultats d'ordination
• Métadonnées : TSV/CSV avec validation

Patrons courants :

import skbio

# Lire avec détection automatique de format
seq = skbio.DNA.read('file.fasta', format='fasta')
tree = skbio.TreeNode.read('tree.nwk')

# Écrire dans un fichier
seq.write('output.fasta', format='fasta')

# Générateur pour les grands fichiers (efficace en mémoire)
for seq in skbio.io.read('large.fasta', format='fasta', constructor=skbio.DNA):
    process(seq)

# Convertir les formats
seqs = list(skbio.io.read('input.fastq', format='fastq', constructor=skbio.DNA))
skbio.io.write(seqs, format='fasta', into='output.fasta')

Remarques importantes :

• Utilisez des générateurs pour les grands fichiers afin d'éviter les problèmes de mémoire
• Le format peut être détecté automatiquement lorsque le paramètre into est spécifié
• Certains objets peuvent être écrits dans plusieurs formats
• Prise en charge du piping stdin/stdout avec verify=False

8. Matrices de distance

Créez et manipulez des matrices de distance/dissimilarité avec des méthodes statistiques.

Capacités clés :

• Stockage de données symétriques (DistanceMatrix, diagonale nulle) ou par paires générales (PairwiseMatrix)
• Indexation et découpage basés sur les IDs
• Intégration avec la diversité, l'ordination et les tests statistiques
• Lecture/écriture en format texte délimité

Patrons courants :

from skbio import DistanceMatrix
import numpy as np

# Créer à partir d'un tableau
data = np.array([[0, 1, 2], [1, 0, 3], [2, 3, 0]])
dm = DistanceMatrix(data, ids=['A', 'B', 'C'])

# Accéder aux distances
dist_ab = dm['A', 'B']
row_a = dm['A']

# Lire depuis un fichier
dm = DistanceMatrix.read('distances.txt')

# Utiliser dans des analyses en aval
pcoa_results = pcoa(dm)
permanova_results = permanova(dm, grouping)

Remarques importantes :

• DistanceMatrix applique la symétrie et une diagonale nulle ; c'est une sous-classe de SymmetricMatrix
• PairwiseMatrix (renommé de DissimilarityMatrix, qui est conservé comme alias obsolète) permet des valeurs générales/asymétriques
• Les IDs permettent l'intégration avec les métadonnées et les connaissances biologiques