Agrégez, lisez et tracez les rapports FASTQC de nombreux échantillons avec le package fastqcr
Contrôlez la qualité des lectures de séquençage brutes en R avec le package fastqcr — agrégez les rapports FASTQC de nombreux échantillons, lisez les résultats module par module, tracez chaque métrique de qualité et signalez les échecs et les avertissements. Un workflow de QC reproductible pour les données de séquençage à haut débit.
.zip de métriques brutes par échantillon. Avec des centaines d’échantillons, vous ne pouvez pas ouvrir chacun à la main — vous devez les lire de façon agrégée.install.packages("fastqcr")) analyse ces sorties .zip et les transforme en data frames bien rangés que vous analysez dans R : agréger sur les échantillons, résumer, signaler les problèmes, lire les résultats module par module et tracer chaque métrique.qc_aggregate() parcourt un répertoire de sorties FASTQC et renvoie un seul data frame long : échantillon × module × statut plus le nombre de lectures, la longueur des lectures, le %GC et le % de doublons.qc_fails() / qc_warns() / qc_problems() répondent aux deux questions qui comptent : quels modules ont échoué sur le plus d’échantillons ? et quels échantillons sont les pires ?qc_read() charge les métriques brutes d’un échantillon (14 éléments) et qc_plot() trace n’importe quel module — qualité par base, contenu en GC, duplication, contenu en adaptateurs — pour que vous puissiez voir pourquoi un signalement a été levé.library(fastqcr)
# One sample's FASTQC report, bundled with the package:
qc.file <- system.file("fastqc_results", "S1_fastqc.zip", package = "fastqcr")
s1 <- qc_read(qc.file) # read all modules for this sample
qc_plot(s1, "Per base sequence quality") # the figure everyone recognizes
La figure FastQC la plus reconnaissable : la qualité des lectures selon la position. La bande verte correspond à une bonne qualité, l’orange à une qualité raisonnable, le rouge à une qualité médiocre — cet échantillon reste dans le vert du début à la fin. C’est ce que fastqcr vous donne pour chaque échantillon et chaque module. Nous revenons à la lecture de chacun plus bas ; d’abord, le workflow qui vous y amène.
Vous venez de recevoir des données de séquençage brutes — un run RNA-seq, un exome, un génome — et le dossier contient un .fastq.gz par échantillon, renfermant des millions de courtes lectures. Avant d’aligner ou de compter quoi que ce soit, vous devez savoir si les lectures brutes sont bonnes : les qualités des bases sont-elles élevées, y a-t-il une contamination par des adaptateurs, le niveau de duplication est-il alarmant ? Cette vérification, c’est le contrôle qualité (QC), et l’outil que tout le monde utilise pour cela est FastQC, un programme de contrôle qualité des lectures de séquençage à haut débit écrit par Simon Andrews au Babraham Institute.
FastQC exécute une série de tests (appelés modules d’analyse) sur chaque échantillon et écrit un rapport HTML ainsi qu’un .zip des chiffres sous-jacents. C’est parfait pour un ou deux échantillons et ingérable pour une centaine — vous n’allez pas parcourir une centaine de pages HTML une par une. C’est exactement la lacune que comble fastqcr : c’est un package R (que nous maintenons) qui lit les sorties .zip de FastQC dans des data frames bien rangés pour que vous puissiez agréger, résumer, inspecter et tracer de nombreux échantillons à la fois — et construire un unique rapport de QC multi-échantillons. Cette leçon vous fait parcourir ce workflow sur les rapports d’exemple fournis avec le package, de sorte que chaque résultat ici est reproductible sur votre propre machine.
fastqcr ne remplace pas FastQC — il lit ce que FastQC a produit et le rend analysable dans R. Les fonctions principales se regroupent en un court pipeline : exécuter FastQC (ou pointer vers une sortie existante), l’agréger, inspecter les problèmes, puis lire et tracer les échantillons individuels.
fastqc_install, fastqc), agréger et résumer les rapports (qc_aggregate, summary, qc_stats), inspecter les problèmes (qc_fails, qc_warns, qc_problems), importer et tracer (qc_read, qc_plot), et construire des rapports HTML (qc_report).Le reste de cette leçon parcourt ces étapes dans l’ordre.
fastqcr est sur CRAN — un simple install.packages(), sans Bioconductor ni Docker :
install.packages("fastqcr")Pour la version de développement, installez depuis GitHub :
if (!require(devtools)) install.packages("devtools")
devtools::install_github("kassambara/fastqcr")Puis chargez-le :
library(fastqcr)La fonction de travail principale est qc_aggregate(). Pointez-la vers un répertoire de sorties FastQC et elle parcourt chaque dossier de résultats compressé, lit le fastqc_data.txt (métriques brutes) et le summary.txt (statut par module) à l’intérieur de chacun, et renvoie un seul data frame long — l’ensemble du run dans un seul objet que vous pouvez filtrer et résumer.
Le package est livré avec un répertoire de démonstration de cinq échantillons afin que vous puissiez exécuter ceci sans vos propres données :
# Demo FASTQC output directory bundled with fastqcr:
qc.dir <- system.file("fastqc_results", package = "fastqcr")
list.files(qc.dir) # five zipped FASTQC reports, S1–S5[1] "S1_fastqc.zip" "S2_fastqc.zip" "S3_fastqc.zip" "S4_fastqc.zip"
[5] "S5_fastqc.zip"Maintenant, agrégez-les :
qc <- qc_aggregate(qc.dir, progressbar = FALSE)
head(qc, 12)# A tibble: 12 × 7
sample module status tot.seq seq.length pct.gc pct.dup
<chr> <chr> <chr> <chr> <chr> <dbl> <dbl>
1 S1 Basic Statistics PASS 50299587 35-76 48 17.2
2 S1 Per base sequence quality PASS 50299587 35-76 48 17.2
3 S1 Per tile sequence quality PASS 50299587 35-76 48 17.2
4 S1 Per sequence quality scores PASS 50299587 35-76 48 17.2
5 S1 Per base sequence content FAIL 50299587 35-76 48 17.2
6 S1 Per sequence GC content WARN 50299587 35-76 48 17.2
7 S1 Per base N content PASS 50299587 35-76 48 17.2
8 S1 Sequence Length Distribution WARN 50299587 35-76 48 17.2
9 S1 Sequence Duplication Levels PASS 50299587 35-76 48 17.2
10 S1 Overrepresented sequences PASS 50299587 35-76 48 17.2
11 S1 Adapter Content PASS 50299587 35-76 48 17.2
12 S1 Kmer Content PASS 50299587 35-76 48 17.2Chaque ligne est un module testé sur un échantillon. Cinq échantillons × douze modules donnent un data frame de 60 lignes. Les colonnes sont :
sample — le nom de l’échantillon.module — le module d’analyse FastQC.status — le verdict de ce module pour cet échantillon : PASS, WARN ou FAIL.tot.seq — le nombre total de séquences (le nombre de lectures).seq.length — la longueur des lectures (une plage lorsque les lectures varient en longueur).pct.gc — le pourcentage de contenu en GC.pct.dup — le pourcentage de lectures dupliquées.Comme il s’agit d’un data frame ordinaire, R de base répond directement à « quel module a levé un signalement sur quel échantillon ? » — sans package supplémentaire :
# Modules that warned or failed, sorted by sample:
flagged <- qc[qc$status %in% c("WARN", "FAIL"), c("sample", "module", "status")]
flagged[order(flagged$sample), ]# A tibble: 15 × 3
sample module status
<chr> <chr> <chr>
1 S1 Per base sequence content FAIL
2 S1 Per sequence GC content WARN
3 S1 Sequence Length Distribution WARN
4 S2 Per base sequence content FAIL
5 S2 Per sequence GC content WARN
6 S2 Sequence Length Distribution WARN
7 S3 Per base sequence content FAIL
8 S3 Per sequence GC content FAIL
9 S3 Sequence Length Distribution WARN
10 S4 Per base sequence content FAIL
11 S4 Per sequence GC content FAIL
12 S4 Sequence Length Distribution WARN
13 S5 Per base sequence content FAIL
14 S5 Per sequence GC content WARN
15 S5 Sequence Length Distribution WARN Trois modules expliquent chaque signalement ici — un schéma que les fonctions de synthèse rendent explicite ensuite.
Deux fonctions transforment le long agrégat en un aperçu par module et par échantillon.
summary() appliqué à l’objet agrégé compte, pour chaque module, combien d’échantillons ont réussi, averti ou échoué — et nomme les fautifs :
summary(qc)# A tibble: 12 × 7
# Groups: module [12]
module nb_samples nb_fail nb_pass nb_warn failed warned
<chr> <dbl> <dbl> <dbl> <dbl> <chr> <chr>
1 Adapter Content 5 0 5 0 <NA> <NA>
2 Basic Statistics 5 0 5 0 <NA> <NA>
3 Kmer Content 5 0 5 0 <NA> <NA>
4 Overrepresented sequences 5 0 5 0 <NA> <NA>
5 Per base N content 5 0 5 0 <NA> <NA>
6 Per base sequence content 5 5 0 0 S1, S… <NA>
7 Per base sequence quality 5 0 5 0 <NA> <NA>
8 Per sequence GC content 5 2 0 3 S3, S4 S1, S…
9 Per sequence quality scores 5 0 5 0 <NA> <NA>
10 Per tile sequence quality 5 0 5 0 <NA> <NA>
11 Sequence Duplication Levels 5 0 5 0 <NA> <NA>
12 Sequence Length Distribution 5 0 0 5 <NA> S1, S…Parcourez les colonnes nb_fail / nb_warn : Per base sequence content échoue dans les 5 échantillons, Per sequence GC content échoue dans 2 (S3, S4) et avertit dans 3 (S1, S2, S5), et Sequence Length Distribution avertit dans les 5. Tous les autres modules passent sans encombre. Voilà votre liste de tri — trois modules à comprendre, neuf que vous pouvez laisser de côté.
qc_stats() réduit le run à une ligne par échantillon avec les chiffres clés :
qc_stats(qc)# A tibble: 5 × 5
sample pct.dup pct.gc tot.seq seq.length
<chr> <dbl> <dbl> <chr> <chr>
1 S1 17.2 48 50299587 35-76
2 S2 15.7 48 50299587 35-76
3 S3 22.1 49 67255341 35-76
4 S4 19.9 49 67255341 35-76
5 S5 18.2 48 65011962 35-76 Les cinq échantillons portent chacun 50–67 millions de lectures, des longueurs de lecture de 35–76 pb, ~48–49 % de GC et 16–22 % de doublons — cohérents d’un échantillon à l’autre, ce à quoi ressemble un run qui se comporte bien. Un unique échantillon avec un GC ou une duplication radicalement différents ressortirait ici immédiatement.
Pour le tri, vous voulez les deux vues directement : quels modules sont les pires sur l’ensemble des échantillons ? et quels échantillons sont les pires globalement ? Trois fonctions les fournissent — qc_fails() (échecs seulement), qc_warns() (avertissements seulement) et qc_problems() (leur union). Chacune prend un argument element, "module" ou "sample".
qc_fails(qc, "module")# A tibble: 2 × 3
module nb_problems sample
<chr> <int> <chr>
1 Per base sequence content 5 S1, S2, S3, S4, S5
2 Per sequence GC content 2 S3, S4 Per base sequence content a échoué dans les 5 échantillons et Per sequence GC content dans 2 — les deux mêmes modules que la synthèse a signalés, à présent classés selon l’ampleur de l’échec. La sortie compacte liste, par module, le nombre d’échecs et les échantillons responsables.
Les avertissements racontent l’histoire complémentaire :
qc_warns(qc, "module")# A tibble: 2 × 3
module nb_problems sample
<chr> <int> <chr>
1 Sequence Length Distribution 5 S1, S2, S3, S4, S5
2 Per sequence GC content 3 S1, S2, S5 Pour zoomer sur un seul module à travers tous ses échantillons, nommez-le (la correspondance partielle fonctionne, donc "GC content" trouve "Per sequence GC content") :
qc_problems(qc, "module", name = "Per sequence GC content")# A tibble: 5 × 4
module nb_problems sample status
<chr> <int> <chr> <chr>
1 Per sequence GC content 5 S3 FAIL
2 Per sequence GC content 5 S4 FAIL
3 Per sequence GC content 5 S1 WARN
4 Per sequence GC content 5 S2 WARN
5 Per sequence GC content 5 S5 WARN Basculez element sur "sample" pour classer les échantillons plutôt que les modules :
qc_fails(qc, "sample")# A tibble: 5 × 3
sample nb_problems module
<chr> <int> <chr>
1 S3 2 Per base sequence content, Per sequence GC content
2 S4 2 Per base sequence content, Per sequence GC content
3 S1 1 Per base sequence content
4 S2 1 Per base sequence content
5 S5 1 Per base sequence content S3 et S4 portent chacun deux modules en échec ; S1, S2 et S5 un chacun — donc S3 et S4 sont les échantillons à examiner en premier. Pour chaque échantillon, la sortie donne le nombre de problèmes et nomme les modules qui ont échoué.
L’agrégation vous donne le tableau au niveau du run ; pour voir pourquoi un module a été signalé, vous lisez les métriques brutes d’un échantillon avec qc_read(), qui renvoie une liste nommée de data frames — un par module :
qc.file <- system.file("fastqc_results", "S1_fastqc.zip", package = "fastqcr")
s1 <- qc_read(qc.file)
length(s1) # number of elements[1] 14names(s1) # one per FastQC module (+ the summary and basic stats) [1] "summary" "basic_statistics"
[3] "per_base_sequence_quality" "per_tile_sequence_quality"
[5] "per_sequence_quality_scores" "per_base_sequence_content"
[7] "per_sequence_gc_content" "per_base_n_content"
[9] "sequence_length_distribution" "sequence_duplication_levels"
[11] "overrepresented_sequences" "adapter_content"
[13] "kmer_content" "total_deduplicated_percentage"Quatorze éléments : les 12 modules d’analyse plus le summary global et le total_deduplicated_percentage. Chaque élément est un data frame bien rangé que vous pourriez inspecter directement — mais la façon la plus rapide de lire un module est de le tracer.
qc_plot() trace n’importe quel module à partir d’un objet qc_read(). Les graphiques ci-dessous sont les figures standard de FastQC, rendues depuis R — et la prose d’interprétation est le vrai bénéfice : savoir ce que mesure chaque module et quand un signalement compte réellement. Les définitions de référence se trouvent dans la documentation des modules d’analyse de FastQC.
Le score de qualité de toutes les lectures à chaque position de base — la figure en haut de cette leçon. Les bandes d’arrière-plan délimitent les zones de qualité : verte (bonne), orange (raisonnable), rouge (médiocre) ; un bon échantillon reste entièrement dans le vert, comme le fait S1. FastQC lève un avertissement si la qualité médiane à une position quelconque descend sous 25, un échec sous 20. Une qualité qui décline vers l’extrémité 3′ est le schéma classique que vous corrigez par un rognage de qualité avant l’alignement.
La distribution de la qualité moyenne par lecture. Elle révèle si un sous-ensemble de lectures est uniformément médiocre. Une bonne librairie culmine loin à droite (qualité moyenne > 27).
qc_plot(s1, "Per sequence quality scores")
Un avertissement se déclenche si la qualité moyenne la plus fréquente est inférieure à 27 (un taux d’erreur de 0.2 %), un échec sous 20 (un taux d’erreur de 1 %). Un pic décalé vers la gauche signifie une perte générale de qualité sur l’ensemble du run.
La proportion de A, C, G et T à chaque position. Dans une librairie aléatoire, les quatre lignes courent à peu près parallèles ; un large écart entre elles signale une composition biaisée.
qc_plot(s1, "Per base sequence content")
FastQC échoue ce module pour l’échantillon de démonstration — mais lisez pourquoi avant de vous inquiéter. Sur presque toute la lecture, les quatre lignes de nucléotides courent plates et parallèles (la composition est uniforme ; l’écart A–T reste sous le seuil d’avertissement de 10 %). L’échec est provoqué par une divergence brusque à la dernière base : A s’effondre vers 0 % tandis que T et C bondissent à environ 37 %. Ce pic en fin de lecture est un artefact de lecture d’adaptateur / d’appel de bases en fin de lecture — il disparaît une fois que vous rognez les adaptateurs et les extrémités de lecture de faible qualité.
L’autre cause classique d’échec de ce module est l’amorçage aléatoire en RNA-seq : les hexamères « aléatoires » utilisés dans la préparation de la librairie ne sont pas vraiment aléatoires et biaisent la composition des ~10–12 premières bases, si bien que presque chaque librairie RNA-seq échoue ici. C’est une signature bien connue de la préparation de librairie, pas un problème de données, et cela n’affecte pas les estimations d’expression. Ainsi, un échec « Per base sequence content » s’explique généralement par l’une de ces deux causes — un artefact de fin de lecture/d’adaptateur ou un biais d’amorçage RNA-seq — plutôt que par une librairie réellement mauvaise.
La distribution du GC à travers les lectures. Une librairie aléatoire donne une courbe à peu près normale centrée sur le GC du génome ; un pic marqué ou décalé laisse entrevoir une contamination ou un biais systématique.
qc_plot(s1, "Per sequence GC content")
Un avertissement signifie que la distribution observée s’écarte modestement de la normale théorique (comme ici) ; un échec signifie un écart important. Un pic secondaire indique souvent un contaminant ou une séquence surreprésentée.
Le pourcentage de bases que le séquenceur n’a pas pu appeler (reportées comme N) à chaque position. Il devrait rester proche de zéro partout.
qc_plot(s1, "Per base N content")
Un avertissement se déclenche au-dessus de 5 % à une position quelconque, un échec au-dessus de 20 %. Un pic accompagne généralement une perte générale de qualité ou une composition fortement biaisée.
Le fait que toutes les lectures partagent une même longueur. Beaucoup de plateformes produisent une longueur unique (un seul pic) ; d’autres varient légitimement, si bien qu’un avertissement ici est souvent bénin.
qc_plot(s1, "Sequence length distribution")
Ces lectures s’étendent de 35 à 76 pb, donc FastQC avertit — mais une longueur variable est normale après le rognage des adaptateurs, donc ce signalement peut être ignoré. Le module n’est réellement en erreur que si une lecture a une longueur nulle.
Le degré de duplication à travers les lectures. Une duplication élevée peut indiquer un biais d’enrichissement tel qu’une suramplification PCR.
qc_plot(s1, "Sequence duplication levels")
Un avertissement se déclenche lorsque les lectures non uniques dépassent 20 % du total, un échec au-dessus de 50 %. En RNA-seq, une duplication de 20–40 % est normale — les gènes fortement exprimés produisent véritablement des lectures identiques — donc vous ne devriez pas dédupliquer aveuglément des données de transcriptome ; un doublon peut être de la biologie, pas un artefact PCR.
Toute séquence unique représentant plus de 0.1 % de la librairie — un signal d’adaptateur, d’amorce ou de contamination par de l’ARNr, ou simplement une faible diversité de la librairie.
qc_plot(s1, "Overrepresented sequences")
Un avertissement se déclenche lorsqu’une séquence dépasse 0.1 % des lectures, un échec au-dessus de 1 %. Les librairies de petits ARN déclenchent naturellement ceci et peuvent constituer une exception.
La fraction cumulée de lectures contenant des séquences d’adaptateurs connues à chaque position. Elle vous indique si un rognage des adaptateurs est nécessaire avant l’analyse en aval.
qc_plot(s1, "Adapter content")
Un avertissement se déclenche lorsque l’adaptateur est présent dans plus de 5 % des lectures à une position quelconque, un échec au-dessus de 10 %. Un signalement ici signifie que vous devriez rogner les adaptateurs avant d’aligner.
Au-delà de l’analyse interactive, qc_report() écrit un rapport HTML partageable — soit un rapport multi-échantillons depuis un répertoire, soit un rapport par échantillon avec les interprétations des graphiques intégrées. Pointez-le vers le répertoire de démonstration :
# Multi-sample report from a directory of FASTQC outputs:
qc_report(qc.dir, result.file = "multi-qc-report",
experiment = "Exome sequencing of colon cancer cell lines")# One-sample report, with the per-module interpretations included:
qc.file <- system.file("fastqc_results", "S1_fastqc.zip", package = "fastqcr")
qc_report(qc.file, result.file = "one-sample-report", interpret = TRUE)Ceux-ci sont présentés comme des appels illustratifs (non exécutés ici) parce qu’ils écrivent des fichiers sur le disque ; exécutez-les localement pour produire les rapports.
Si vous n’avez pas encore de sortie FastQC, fastqcr peut installer et exécuter l’outil FastQC pour vous sur macOS/Linux — fastqc_install() récupère la dernière version, et fastqc() l’exécute sur un répertoire de fichiers FASTQ :
fastqc_install() # install the FastQC tool (macOS / Linux)
fastqc(fq.dir = "~/Documents/FASTQ", # directory of .fastq(.gz) files
qc.dir = "~/Documents/FASTQC", # where to write the reports
threads = 4)FastQC accepte le FASTQ et le FASTQ compressé par gzip. Une fois qu’il a écrit ses sorties .zip, vous êtes de retour au sommet de ce workflow avec qc_aggregate().
qc_aggregate() renvoie un data frame vide ou partiel. Il attend les dossiers de sortie FastQC compressés (*_fastqc.zip) tels que FastQC les écrit — pointez qc.dir vers le répertoire qui contient ces fichiers .zip, pas vers un dossier décompressé ou les fichiers FASTQ. Si vous les avez décompressés, qc_unzip() et le répertoire de dossiers décompressés fonctionnent aussi.
Tous les échantillons de démonstration échouent à « Per base sequence content » — ce n’est généralement pas un vrai défaut. Pour ces rapports, l’échec provient d’un artefact de fin de lecture/d’adaptateur à la dernière base, éliminé par le rognage. Dans les données RNA-seq, le même module échoue presque universellement pour une raison différente — un biais d’amorçage aléatoire sur les ~10–12 premières bases — qui est de même une signature connue de la préparation de librairie, pas un problème de données, et n’affecte pas la quantification de l’expression.
Un avertissement paraît alarmant mais est bénin. Les seuils de FastQC sont génériques ; un type de librairie peut légitimement déclencher un module (longueur de lecture variable après rognage, forte duplication due à des gènes fortement exprimés, composition biaisée dans les librairies au bisulfite). Traitez WARN/FAIL comme « regardez ici », pas comme « jetez l’échantillon » — lisez le module et décidez en contexte.
FastQC est un outil de contrôle qualité des lectures de séquençage à haut débit : il exécute un ensemble de modules d’analyse sur chaque échantillon et écrit un rapport HTML plus un .zip de métriques brutes. fastqcr est un package R qui lit ces sorties .zip dans des data frames bien rangés pour que vous puissiez agréger, résumer, inspecter et tracer de nombreux échantillons à la fois dans R — et construire un unique rapport multi-échantillons — au lieu d’ouvrir une page HTML par échantillon.
Pointez qc_aggregate() vers le répertoire contenant les sorties FastQC compressées : qc <- qc_aggregate("path/to/fastqc_results"). Elle renvoie un seul data frame long avec une ligne par échantillon × module, portant le statut et les statistiques générales (lectures, longueur, %GC, % de doublons). À partir de là, summary(qc), qc_stats(qc) et qc_fails(qc, "module") résument l’ensemble du run.
Ce sont les verdicts par module de FastQC par rapport à des seuils fixes : PASS = normal, WARN = légèrement inhabituel, FAIL = très inhabituel. Ce sont des indicateurs, pas une note de réussite/échec pour l’échantillon — certains types de librairie sont censés déclencher des modules spécifiques (p. ex. le RNA-seq échoue à per base sequence content). Lisez toujours le module signalé en contexte avant d’agir.
Généralement non. Une duplication de 20–40 % en RNA-seq est normale car les gènes fortement exprimés produisent véritablement des lectures identiques, si bien que vous ne pouvez pas distinguer un doublon PCR d’une réelle expression élevée. FastQC peut avertir ou échouer le module de duplication, mais dédupliquer aveuglément des données de transcriptome supprime du signal. La déduplication a davantage de sens pour les applications ADN avec des UMI.
Deux causes courantes, toutes deux bénignes. Les artefacts de fin de lecture / d’adaptateur faussent la composition de la ou des dernières bases — c’est ce qui fait échouer le module pour les rapports de démonstration ici — et disparaissent une fois que vous rognez les adaptateurs et les extrémités de faible qualité. Séparément, l’amorçage aléatoire en RNA-seq biaise les ~10–12 premières bases parce que les hexamères « aléatoires » utilisés dans la préparation de la librairie ne sont pas vraiment aléatoires ; cela déclenche le module pour presque toutes les librairies RNA-seq. Ni l’un ni l’autre n’est un défaut réparable, et aucun n’affecte la mesure de l’expression, donc on peut généralement les noter sans risque et passer à la suite.
En utilisant le répertoire de démonstration fourni, agrégez les cinq rapports FastQC et répondez à deux questions : (1) quel module a échoué dans le plus d’échantillons, et (2) quel échantillon a le plus de modules en échec ?
Agrégez avec qc_aggregate(), puis appelez qc_fails() deux fois — une fois avec element = "module" et une fois avec element = "sample".
library(fastqcr)
qc.dir <- system.file("fastqc_results", package = "fastqcr")
qc <- qc_aggregate(qc.dir, progressbar = FALSE)
qc_fails(qc, "module") # (1) Per base sequence content — failed in all 5 samples
qc_fails(qc, "sample") # (2) S3 and S4 — two failed modules eachPer base sequence content est l’échec le plus répandu (les 5 échantillons — le biais d’amorçage RNA-seq), et S3 / S4 sont les pires échantillons avec deux modules en échec chacun. Ni l’un ni l’autre n’est une raison de jeter des données ici ; les deux se lisent en contexte.
A. Per base sequence quality B. Per base sequence content C. Adapter content
B. Per base sequence content échoue pour presque chaque librairie RNA-seq parce que l’amorçage aléatoire biaise les premières bases de chaque lecture — c’est attendu et cela n’affecte pas les estimations d’expression. Un échec de per base sequence quality (mauvais scores Phred) ou d’adapter content (contamination) est un vrai problème sur lequel vous agiriez par du rognage.
Vous avez exécuté un workflow complet de QC de séquençage dans R : qc_aggregate() a transformé un répertoire de sorties FastQC en un seul data frame analysable, summary() et qc_stats() ont résumé le run par module et par échantillon, et qc_fails() / qc_warns() / qc_problems() ont classé les problèmes des deux manières. Ensuite, qc_read() et qc_plot() vous ont permis d’ouvrir un seul échantillon et de lire la figure de chaque module — et, surtout, de décider si un signalement compte (un échec de per-base-content en RNA-seq est attendu ; une mauvaise qualité de base ou une contamination par des adaptateurs ne l’est pas). Le QC terminé, les lectures sont prêtes pour l’alignement et la quantification en une matrice de comptage.
Cette leçon est reproductible : chaque tableau et chaque figure de cette page a été produit par le code montré, sur les rapports d’exemple fournis avec fastqcr — copiez n’importe quel bloc et exécutez-le pour reproduire ces résultats. The runtime is the judge.
@online{2026,
author = {},
title = {Contrôle qualité FASTQC en R avec fastqcr},
date = {2026-07-08},
url = {https://www.datanovia.com/learn/bioinformatics/genomics/fastqcr},
langid = {fr}
}