TP module 24

Auteur·rice·s
Affiliations

Olivier Rué

MaIAGE

Valentin Loux

MaIAGE

Cédric Midoux

PROSE & MaIAGE

Date de publication

20 mai 2026

Modifié

26 mai 2026

Avertissement

Les réponses aux questions de ce TP peuvent être visibles en appuyant sur le bouton Solution. À n’utiliser que si vous bloquez bien sûr !

1 Rappels sur les ressources de la plateforme Migale

L’objectif de cette partie est de présenter comment lancer des calculs sur l’infrastructure de migale (serveur front).

AstuceCréer cette arborescence dans votre espace work
TRAINING/
├── CLUSTER/
└── ANALYSES/
Solution
mkdir -p ~/work/TRAINING/CLUSTER
mkdir -p ~/work/TRAINING/ANALYSES
cd ~/work/TRAINING
AstuceSe déplacer dans le répertoire CLUSTER et faire un lien symbolique des fichiers présents dans le répertoire /save_projet/metagenomics_training/cluster/
Solution
cd ~/work/TRAINING/CLUSTER
ln -s /save_projet/metagenomics_training/cluster/* .
AstuceTrouver l’environnement conda de blast
Solution
conda info --envs |grep blast
# blast-2.16.0             /usr/local/genome/miniforge3/envs/blast-2.16.0
# blast-legacy-2.2.26      /usr/local/genome/miniforge3/envs/blast-legacy-2.2.26
# rmblast-2.14.1           /usr/local/genome/miniforge3/envs/rmblast-2.14.1
AstuceAligner avec blastn query.fasta sur subject.fasta (les indexs blast sont déjà générés), en déportant le calcul sur le cluster en utilisant 4 threads
Solution
qsub -cwd -V -q web.q -N myblast -pe thread 4 -b y "conda activate blast-2.16.0 && blastn -db subject.fasta -query query.fasta -out out.blast -num_threads 4 && conda deactivate"
AstuceComment vérifier que le job s’est bien terminé ?
Solution
# Vérifier le fichier de sortie out.blast
# Vérifier qu'il n'y a pas de message d'erreur dans les fichier .o et .e
AstuceAligner tous les fichiers query*.fasta. Il faut pour cela itérer sur les fichiers d’entrée pour lancer les soumissions
Solution
# Solution 1

for i in query*.fasta ; do qsub -cwd -V -q web.q -N myblast -pe thread 4 -b y "conda activate blast-2.16.0 && blastn -db subject.fasta -query $i -out out-$i.blast -num_threads 4 && conda deactivate" ; done

# Solution 2

for i in query*.fasta ; do echo "conda activate blast-2.16.0 && blastn -db subject.fasta -query $i -out $i.blast -num_threads 4 && conda deactivate" >> myblast.sh ; done
qarray -cwd -V -q web.q -N myblast -pe thread 4 myblast.sh

1.1 Préparation de l’espace de travail et organisation

Note

Pour une question de reproductibilité et de tracabilité, les commandes que nous enverrons sur le cluster seront stockées dans des fichiers .sh, nommés en fonction de l’outil à lancer.

AstuceSe déplacer dans le répertoire ANALYSES puis faire un lien symbolique des fichiers présents dans le répertoire /save_projet/metagenomics_training/simulated_reads/
Solution
cd ~/work/TRAINING/ANALYSES
ln -s /save_projet/metagenomics_training/simulated_reads/* .
AstuceCréer un répertoire LOGS dans lequel seront stockés les fichiers spécifiques à la soumission des jobs sur le cluster de calcul
Solution
mkdir ~/work/TRAINING/ANALYSES/LOGS

2 Contrôle Qualité des reads

Avertissement

Cette étape sert avant tout à vérifier que les fichiers récupérés et sur lesquels on s’apprête à travailler sont conformes à ce qu’on a demandé au prestataire de séquençage

Choses à vérifier :

  • on a autant de fichiers que d’échantillons envoyés
  • on a un nombre de reads suffisants par échantillon
  • on a des tailles de reads conformes à l’attendu

2.1 Nombre de reads

AstuceCombien de reads sont présents dans les fichiers s1_R1.fastq.gz et s1_R2.fastq.gz ?

Étape 1: Utiliser la commande zcat pour lire un fichier compressé et wc -l pour compter le nombre de lignes

Solution
zcat s1_R1.fastq.gz | wc -l

Étape 2: Un read correspondant à 4 lignes dans un fichier FASTQ, il faut diviser le nombre de lignes par 4

Solution
zcat s1_R1.fastq.gz | echo $((`wc -l`/4))

Étape 3: Automatiser le calcul pour tous les fichiers au format FASTQ présents dans le répertoire d’intérêt, et afficher le nom du fichier

Solution
for i in *.fastq.gz ; do echo $i $(zcat $i | echo $((`wc -l`/4))) ; done
# s1_R1.fastq.gz 1000002
# s1_R2.fastq.gz 1000002
# ...

2.2 Contenu des fichiers

AstuceVérifier que les fichiers FASTQ sont conformes et obtenir des statistiques sur leur contenu avec l’outil seqkit [1]

Étape 1: Trouver l’environnement conda de seqkit

Solution
conda info --envs |grep seqkit
# seqkit-2.13.0            /usr/local/genome/miniforge3/envs/seqkit-2.13.0
# seqkit-2.9.0             /usr/local/genome/miniforge3/envs/seqkit-2.9.0

Étape 2: Explorer les options de seqkit et identifier les paramètres intéréssants

Solution
conda activate seqkit-2.13.0
seqkit stat -h

# simple statistics of FASTA/Q files
# ...
# Usage:
#   seqkit stats [flags] 
# ...

Étape 3: Lancer le module stat de l’outil seqkit sur tous les fichiers FASTQ

Solution
echo "conda activate seqkit-2.13.0 && seqkit stat --all *.fastq.gz > seqkit.txt && conda deactivate" > seqkit.sh
qsub -cwd -V -q web.q -N seqkit -o LOGS -e LOGS seqkit.sh

Étape 4: Lire le fichier de sortie

Solution
cat seqkit.txt

# file            format  type   num_seqs      sum_len  min_len  avg_len  max_len   Q1   Q2   Q3  sum_gap  N50  N50_num  Q20(%)  Q30(%)  AvgQual  GC(%)  sum_n
# s1_R1.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   96.11    92.3    27.25  50.79      0
# s1_R2.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   94.77   90.19    26.12  50.77      0
# s2_R1.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   96.12   92.31    27.26  50.93      0
# s2_R2.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   94.76   90.15    26.11  50.91      0
# s3_R1.fastq.gz  FASTQ   DNA   1,000,000  126,000,000      126      126      126  126  126  126        0  126        1   96.11    92.3    27.26   49.5      0
# s3_R2.fastq.gz  FASTQ   DNA   1,000,000  126,000,000      126      126      126  126  126  126        0  126        1   94.74   90.13     26.1  49.45      0
# s4_R1.fastq.gz  FASTQ   DNA     500,030   63,003,780      126      126      126  126  126  126        0  126        1   96.12   92.31    27.26  49.56      0
# s4_R2.fastq.gz  FASTQ   DNA     500,030   63,003,780      126      126      126  126  126  126        0  126        1   94.76   90.17    26.12   49.5      0
# s5_R1.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   96.11    92.3    27.25  50.79      0
# s5_R2.fastq.gz  FASTQ   DNA   1,000,002  126,000,252      126      126      126  126  126  126        0  126        1   94.77   90.19    26.12  50.77      0

2.3 FastQC

FastQC [2] est utilisé pour vérifier la qualité des données issues d’un séquençage NGS. La qualité de base des reads, le contenu en adaptateurs, le nombre de séquences uniques… sont des métriques qu’il faut regarder avec attention.

AstuceLancer FastQC sur chaque échantillon

Étape 1: Trouver l’environnement conda de fastqc

Solution
conda info --envs |grep fastqc
# fastqc-0.11.9            /usr/local/genome/miniforge3/envs/fastqc-0.11.9
# fastqc-0.12.1            /usr/local/genome/miniforge3/envs/fastqc-0.12.1

Étape 2: Faire une boucle pour lancer FastQC sur tous les fichiers FASTQ présents dans le répertoire, en utilisant 4 threads

Solution
mkdir FASTQC
for i in *.fastq.gz ; do echo "conda activate fastqc-0.12.1 && fastqc --outdir FASTQC/ --threads 4 $i && conda deactivate" >> fastqc.sh ; done

Étape 3: Lancer les traitements en parallèle sur le cluster grâce à la commande qarray

Solution
qarray -cwd -V -q web.q -N fastqc -pe thread 4 -o LOGS/ -e LOGS/ fastqc.sh

2.4 MultiQC

MultiQC [3] est un outil qui permet d’agglomérer les résultats de FastQC en un seul rapport. Il est particulièrement utile quand on travaille sur beaucoup d’échantillons.

AstuceLancer MultiQC et écrire les résultats dans le répertoire MULTIQC
Solution
conda info --envs |grep multiqc
# multiqc-1.12             /usr/local/genome/miniforge3/envs/multiqc-1.12
# multiqc-1.27.1           /usr/local/genome/miniforge3/envs/multiqc-1.27.1

mkdir MULTIQC
echo "conda activate multiqc-1.27.1 && multiqc --outdir MULTIQC/ FASTQC/ && conda deactivate" > multiqc.sh
qsub -cwd -V -q web.q -N multiqc -o LOGS -e LOGS multiqc.sh
AstuceVisualiser le rapport
Solution
firefox --no-remote MULTIQC/multiqc_report.html &

3 Assignation taxonomique

Avant même de nettoyer les reads, il peut s’avérer utile d’effectuer une classification taxonomique. Cela permet entre autres de détecter une contamination (hôte, environnement, humain…) ou bien de vérifier si les données sont cohérentes avec ce qu’on attend.

Important

Attention au choix de la banque, qui peut fausser l’interprétation !

Kraken2 [4] propose des banques préformatées ici. Nous allons utiliser ici la banque k2_standard_16_GB_20260226.

Les banques spécifiques à Kraken sont mises à disposition dans le répertoire suivant : /db/outils/kraken2-2026/

AstuceObtenir un Krona représentant la diversité de nos échantiilons

Étape 1: Trouver l’environnement conda de kraken2

Solution
conda info --envs |grep kraken2
# kraken2-2.14             /usr/local/genome/miniforge3/envs/kraken2-2.14
# kraken2-2.17.1           /usr/local/genome/miniforge3/envs/kraken2-2.17.1

Étape 2: Assigner les reads bruts avec Kraken2 contre la banque k2_standard_16_GB_20260226. Écrire les résultats dans le répertoire KRAKEN2.

Les banques dédiées à Kraken2 sont situées dans /db/outils/kraken2*.

Solution
mkdir KRAKEN2
for i in *_R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate kraken2-2.17.1 && k2 classify --db /db/outils/kraken2-2026/k2_standard_16_GB_20260226/ $i ${id}_R2.fastq.gz --paired --quick --output KRAKEN2/${id} --threads 16 && conda deactivate" >> kraken2.sh ; done
qarray -cwd -V -q web.q -o LOGS -e LOGS -N kraken2 -pe thread 16 kraken2.sh

Étape 3: Générer le fichier Krona avec la suite Krona-tools [5]

Solution
conda info --envs |grep krona
# krona-2.8.1            /usr/local/genome/miniforge3/envs/krona-2.8.1

for i in *_R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate krona-2.8.1 && ktImportTaxonomy -t 3 KRAKEN2/${id} -o KRAKEN2/${id}.html -tax /db/outils/KRONA-taxo/current/taxonomy/ && conda deactivate" >> krona.sh ; done
qarray -cwd -V -q web.q -o LOGS -e LOGS -N krona krona.sh

# ou

echo "conda activate krona-2.8.1 && ktImportTaxonomy -tax /db/outils/KRONA-taxo/current/taxonomy/ -t 3 KRAKEN2/s[12345] -o KRAKEN2/all.html  && conda deactivate" >> krona_single.sh
qsub -cwd -V -q web.q -N krona -o LOGS -e LOGS krona_single.sh

Étape 5: Visualiser le fichier HTML généré

Solution
firefox --no-remote KRAKEN2/s1.html &
firefox --no-remote KRAKEN2/all.html &

Nous allons utiliser ici l’outil Kaiju [6] avec la banque RefSeq.

Les banques spécifiques à kaiju sont mises à disposition dans le répertoire suivant : /db/outils/kaiju-2024/

AstuceObtenir un Krona représentant la diversité de nos échantiilons

Étape 1: Trouver l’environnement conda de kaiju

Solution
conda info --envs |grep kaiju
# kaiju-1.10.1             /usr/local/genome/miniforge3/envs/kaiju-1.10.1

Étape 2: Assigner les reads bruts avec kaiju contre la banque RefSeq. Écrire les résultats dans le répertoire KAIJU

Les banques dédiées à kaiju sont situées dans /db/outils/. La plus récente aujourd’hui est /db/outils/kaiju-2024/.

Solution
mkdir KAIJU
for i in *_R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate kaiju-1.10.1 && kaiju -t /db/outils/kaiju-2024/nodes.dmp -f /db/outils/kaiju-2024/nr/kaiju_db_nr.fmi -i $i -j ${id}_R2.fastq.gz -o KAIJU/${id} -z 16 && conda deactivate" >> kaiju.sh ; done
qarray -cwd -V -q web.q -N kaiju -o LOGS -e LOGS -pe thread 16 kaiju.sh

Étape 3: Corriger les éventuels taxons qui auraient changé entre la version de la banque Kaiju celle utilisée par krona, en utilisant le script /save_projet/metagenomics_training/scripts/update_taxid_column_from_merged_ncbi_file.py.

Solution
cp /save_projet/metagenomics_training/scripts/update_taxid_column_from_merged_ncbi_file.py .
for i in KAIJU/* ; do echo "python3 update_taxid_column_from_merged_ncbi_file.py --dump /db/ncbi_taxon/current/flat/merged.dmp --file $i --taxid-col 3 > $i.cor" >> update_taxo.sh ; done
qarray -cwd -V -q web.q -o LOGS -e LOGS -N updatetaxonomy update_taxo.sh

Étape 4: Générer le fichier Krona avec la suite Krona-tools [5]

Solution
conda info --envs |grep krona
# krona-2.8.1              /usr/local/genome/miniforge3/envs/krona-2.8.1

for i in KAIJU/*.cor ; do echo "conda activate krona-2.8.1 && ktImportTaxonomy -tax /db/outils/KRONA-taxo/current/taxonomy/ -t 3 -q 2 $i -o $i.html && conda deactivate" >> krona.sh ; done
qarray -cwd -V -q web.q -N krona -o LOGS -e LOGS krona.sh

# ou

echo "conda activate krona-2.8.1 && ktImportTaxonomy -tax /db/outils/KRONA-taxo/current/taxonomy/ -t 3 -q 2 KAIJU/*.cor -o KAIJU/all.html && conda deactivate" >> krona_single.sh
qsub -cwd -V -q web.q -N krona -o LOGS -e LOGS krona_single.sh

Étape 5: Visualiser le fichier HTML généré

Solution
firefox --no-remote KAIJU/kaiju.cor.html &
firefox --no-remote KAIJU/all.html &

4 Nettoyage

4.1 Filtrer et trimmer les reads

FASTP [7] est un outil de préprocessing qui permet d’éliminer les séquences de mauvaise qualité, les bases ambigües, les séquences trop courtes, ainsi de les adaptateurs restants.

AstuceExplorez les paramètres de FASTP et lancez FASTP sur les données brutes

Étape 1: Trouver l’environnement conda de fastp

Solution
conda info --envs |grep fastp
# fastp-0.24.0             /usr/local/genome/miniforge3/envs/fastp-0.24.0

Étape 2: Identifier les paramètres obligatoires et les valeurs par défaut

Solution
conda activate fastp-0.24.0
fastp -h
#  -i, --in1                            read1 input file name (string [=])
#  -o, --out1                           read1 output file name (string [=])
#  -I, --in2                            read2 input file name (string [=])
#  -O, --out2                           read2 output file name (string [=])
#
#  -a, --adapter_sequence               if not specified, the adapter will be auto-detected.
#  -M, --cut_mean_quality               the mean quality requirement option. default: 20 (Q20)
#  -n, --n_base_limit                   if one read's number of N base is >n_base_limit, then this read/pair is discarded. Default is 5 (int [=5])
#  -l, --length_required                reads shorter than length_required will be discarded, default is 15. (int [=15])
#  ...

Étape 3: Soumettre le job et écrire les sorties dans un répertoire FASTP

Solution
mkdir FASTP
for i in *_R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate fastp-0.24.0 && fastp --in1 $i --in2 ${id}_R2.fastq.gz --out1 FASTP/${id}_R1.fastq.gz --out2 FASTP/${id}_R2.fastq.gz --verbose --length_required 50 --html FASTP/${id}_fastp.html --json FASTP/${id}_fastp.json --thread 4 && conda deactivate" >> fastp.sh ; done
qarray -cwd -V -q web.q -N fastp -pe thread 4 -o LOGS/ -e LOGS/ fastp.sh
AstuceVérifier l’effet du nettoyage
Solution
# avec seqkit
# avec multiqc
# en comptant le nombre de lignes dans les fichiers...

4.2 Enlever des contaminants par mapping

Dans certains projets, il peut être intéressant de filtrer les séquences d’un contaminant (hôte, contaminants connus…)

Dans nos échantillons, il n’y a pas réellement d’hôte, mais voici par exemple la procédure pour écarter les séquences d’un des génomes viraux présents dans le jeu de données. Il s’agit de la séquence de Sorex araneus polyomavirus 1 isolate qui est présente dans le fichier /save_projet/metagenomics_training/contaminants/conta.fasta.

AstuceSupprimer les reads mappant sur la séquence présente dans le fichier conta.fasta

Étape 1: Copier le fichier /save_projet/metagenomics_training/contaminants/conta.fasta dans un nouveau répertoire HOCORT

Solution
mkdir HOCORT
cp /save_projet/metagenomics_training/contaminants/conta.fasta HOCORT/conta.fasta

Étape 2: Indexer le fichier FASTA avec HoCoRT [8]

Solution
conda info --envs |grep hocort
# hocort-1.2.2             /usr/local/genome/miniforge3/envs/hocort-1.2.2

echo "conda activate hocort-1.2.2 && hocort index bowtie2 --input HOCORT/conta.fasta --output HOCORT/conta && conda deactivate" > hocort_index.sh
qsub -cwd -V -q web.q -N hocort_index -o LOGS -e LOGS hocort_index.sh

Étape 3: Extraire les reads qui ne mappent pas sur cette banque

Solution
for i in FASTP/*R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate hocort-1.2.2 && hocort map bowtie2 -x HOCORT/conta -i FASTP/${id}_R1.fastq.gz FASTP/${id}_R2.fastq.gz -o HOCORT/${id}_R1.fastq.gz HOCORT/${id}_R2.fastq.gz --filter true -t 8 && conda deactivate" >> hocort.sh ; done

qarray -cwd -V -q web.q -N hocort -o LOGS -e LOGS -pe thread 8 -R y hocort.sh

conda activate seqkit-2.13.0 && seqkit stat HOCORT/*.fastq.gz > HOCORT/seqkit.txt && conda deactivate

Dans certains projets, il peut être intéressant de filtrer les séquences d’un contaminant (hôte, contaminants connus…)

Dans nos échantillons, il n’y a pas réellement d’hôte, mais voici par exemple la procédure pour écarter les séquences d’un des génomes viraux présents dans le jeu de données. Il s’agit de la séquence de Sorex araneus polyomavirus 1 isolate qui est présente dans le fichier /save_projet/metagenomics_training/contaminants/conta.fasta.

AstuceSupprimer les reads mappant sur la séquence présente dans le fichier conta.fasta

Étape 1: Copier le fichier /save_projet/metagenomics_training/contaminants/conta.fasta dans un nouveau répertoire DECONTA_MAPPING

Solution
mkdir DECONTA_MAPPING
cp /save_projet/metagenomics_training/contaminants/conta.fasta DECONTA_MAPPING/conta.fasta

Étape 2: Indexer le fichier FASTA avec bwa [9]

Solution
conda info --envs |grep bwa
# bwa-0.7.18               /usr/local/genome/miniforge3/envs/bwa-0.7.18
# bwa-fastalign-1.0.0      /usr/local/genome/miniforge3/envs/bwa-fastalign-1.0.0
# bwa-mem2-2.2.1           /usr/local/genome/miniforge3/envs/bwa-mem2-2.2.1
# bwa-mem2-2.3             /usr/local/genome/miniforge3/envs/bwa-mem2-2.3

echo "conda activate bwa-0.7.18 && bwa index DECONTA_MAPPING/conta.fasta && conda deactivate" > bwa_index.sh
qsub -cwd -V -q web.q -N bwa_index -o LOGS -e LOGS bwa_index.sh

Étape 3: Mapper tous les reads sur cette banque

Solution
conda info --envs |grep samtools
# msamtools-1.1.3          /usr/local/genome/miniforge3/envs/msamtools-1.1.3
# samtools-1.14            /usr/local/genome/miniforge3/envs/samtools-1.14
# samtools-1.21            /usr/local/genome/miniforge3/envs/samtools-1.21

for i in FASTP/*R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate samtools-1.21 && conda activate bwa-0.7.18 --stack && bwa mem -t 4 DECONTA_MAPPING/conta.fasta $i FASTP/${id}_R2.fastq.gz | samtools view -hbS - | samtools sort -n -@ 4 - > DECONTA_MAPPING/${id}.bam && samtools index DECONTA_MAPPING/${id}.bam && conda deactivate && conda deactivate" >> mapping_conta.sh ; done
qarray -cwd -V -q web.q -N bwa -o LOGS -e LOGS -pe thread 9 -R y mapping_conta.sh

Étape 4: Analyse de l’alignement avec samtools flagstat

Solution
for i in DECONTA_MAPPING/*.bam ; do conda activate samtools-1.14 && samtools flagstat $i > $i.flagstat && conda deactivate ; done

Étape 5: Extraction des reads ne mappant pas avec bedtools bamToFastq [10]

Solution
conda info --envs |grep bedtools
# bedtools-2.31.1          /usr/local/genome/miniforge3/envs/bedtools-2.31.1

for i in DECONTA_MAPPING/*.bam ; do id=$(basename $i .bam) ; echo "conda activate bedtools-2.31.1 && bamToFastq -i $i -fq DECONTA_MAPPING/${id}_R1.fastq -fq2 DECONTA_MAPPING/${id}_R2.fastq && conda deactivate" >> bam2fastq.sh ; done

qarray -cwd -V -q web.q -N bam2fastq -o LOGS -e LOGS bam2fastq.sh

for i in DECONTA_MAPPING/*.fastq ; do gzip $i ; done

conda activate seqkit-2.13.0 && seqkit stat DECONTA_MAPPING/*.fastq.gz > DECONTA_MAPPING/seqkit.txt && conda deactivate

5 Assembler les reads

Maintenant que les reads sont nettoyés, nous pouvons passer à l’assemblage. Cette étape consiste en la construction de longs contigs à partir des reads.

Pour ce jeu de données nous avons choisi d’effectuer un assemblage poolé de tous nos échantillons. Dans certains cas, il peut être intéressant d’assembler les échantillons séparément. Nous vous proposons aujourd’hui d’utiliser MEGAHIT [11].

AstuceAssembler les reads avec megahit

Étape 1: Trouver l’environnement conda de megahit [11].

Solution
conda info --envs |grep megahit
# megahit-1.2.9            /usr/local/genome/miniforge3/envs/megahit-1.2.9

Étape 2: Lancer l’assemblage

Solution
echo "conda activate megahit-1.2.9 && megahit -1 HOCORT/s1_R1.fastq.gz,HOCORT/s2_R1.fastq.gz,HOCORT/s3_R1.fastq.gz,HOCORT/s4_R1.fastq.gz,HOCORT/s5_R1.fastq.gz -2 HOCORT/s1_R2.fastq.gz,HOCORT/s2_R2.fastq.gz,HOCORT/s3_R2.fastq.gz,HOCORT/s4_R2.fastq.gz,HOCORT/s5_R2.fastq.gz --num-cpu-threads 8 --memory 20 --tmp-dir /projet/tmp --out-dir MEGAHIT/" > megahit.sh
qsub -cwd -V -q web.q -N megahit -pe thread 8 -o LOGS/ -e LOGS/ megahit.sh

SPAdes [12] est l’un des assembleur les plus populaire et les plus actifs sur le front des assemblages de lectures courtes. Il est primordial d’utiliser l’option --meta pour les projets de métagénomiques.

AstuceAssembler les reads avec SPAdes

Étape 1: Trouver l’environnement conda de SPAdes

Solution
conda info --envs |grep spades
# spades-4.1.0             /usr/local/genome/miniforge3/envs/spades-4.1.0

Étape 2: Préparer la commande

Solution
mkdir SPADES

for i in HOCORT/*R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate spades-4.1.0 && spades.py --threads 8 --memory 10 --tmp-dir /projet/tmp --meta -1 HOCORT/${id}_R1.fastq.gz -2 HOCORT/${id}_R2.fastq.gz -o SPADES/${id} && conda deactivate" >> spades.sh ; done

Étape 3: Soumettre le job

Solution
qarray -cwd -V -q web.q -N spades -pe thread 8 -o LOGS/ -e LOGS/ spades.sh

5.1 Évaluation de la qualité de l’assemblage

QUAST [13] permet d’obtenir et d’évaluer les métriques d’assemblage.

AstuceLancer quast sur l’assemblage en ne prenant en compte que les contigs supérieus à 500 bp
Solution
echo "conda activate quast-5.3.0 && HOME=/projet/tmp/$USER && metaquast.py MEGAHIT/final.contigs.fa -o QUAST --min-contig 500 && conda deactivate" > quast.sh
qsub -cwd -V -q web.q -N quast -o LOGS/ -e LOGS/ quast.sh
AstuceUtiliser les références présentes dans le répertoire /save_projet/metagenomics_training/refs/ pour avoir des informations ciblées
Solution
echo "conda activate quast-5.3.0 && HOME=/projet/tmp/$USER && metaquast.py MEGAHIT/final.contigs.fa -o QUAST_REFS/ -r /save_projet/metagenomics_training/refs/ --min-contig 500 && conda deactivate" > quast_refs.sh
qsub -cwd -V -q web.q -N quast_refs -o LOGS/ -e LOGS/ quast_refs.sh

5.2 Mapping des reads sur les contigs

Maintenant, on aimerait replacer les reads sur les contigs pour obtenir les informations de couverture et de profondeur.

AstuceObtenir les infos de couverture et profondeur à partir des alignements

Étape 1: Créer un répertoire MAPPING_ON_ASSEMBLY

Nous allons avoir besoin de bwa [9] et de samtools [14].

Solution
conda info --envs |grep bwa
# bwa-0.7.18               /usr/local/genome/miniforge3/envs/bwa-0.7.18
# bwa-fastalign-1.0.0      /usr/local/genome/miniforge3/envs/bwa-fastalign-1.0.0
# bwa-mem2-2.2.1           /usr/local/genome/miniforge3/envs/bwa-mem2-2.2.1
# bwa-mem2-2.3             /usr/local/genome/miniforge3/envs/bwa-mem2-2.3 

conda info --envs |grep samtools
# msamtools-1.1.3          /usr/local/genome/miniforge3/envs/msamtools-1.1.3
# samtools-1.14            /usr/local/genome/miniforge3/envs/samtools-1.14
# samtools-1.21            /usr/local/genome/miniforge3/envs/samtools-1.21

Étape 2: Indexer les contigs avec bwa [9]

Solution
echo "conda activate bwa-0.7.18 && bwa index MEGAHIT/final.contigs.fa && conda deactivate" > bwa_index_contigs.sh
qsub -cwd -V -q web.q -N bwa_index_contigs -o LOGS -e LOGS bwa_index_contigs.sh

Étape 3: Mapper les reads

Solution
mkdir MAPPING_ON_ASSEMBLY

for i in HOCORT/*_R1.fastq.gz ; do id=$(basename $i _R1.fastq.gz) ; echo "conda activate samtools-1.14 && conda activate bwa-0.7.18 --stack && bwa mem -t 4 MEGAHIT/final.contigs.fa HOCORT/${id}_R1.fastq.gz HOCORT/${id}_R2.fastq.gz | samtools view -hbS - | samtools sort -@ 4 - > MAPPING_ON_ASSEMBLY/${id}.bam && samtools index MAPPING_ON_ASSEMBLY/${id}.bam && conda deactivate" >> bwa_contigs.sh ; done
qarray -cwd -V -q web.q -N bwa_contigs -o LOGS -e LOGS -pe thread 8 -R y bwa_contigs.sh
AstuceCombien de reads sont mappés sur les contigs ? Utiliser l’outil samtools flagstat
Solution
for i in MAPPING_ON_ASSEMBLY/*.bam ; do conda activate samtools-1.14 && samtools flagstat $i > $i.flagstat && conda deactivate ; done
AstuceUtiliser samtools pour évaluer la profondeur et la couverture
Solution
for i in MAPPING_ON_ASSEMBLY/*.bam ; do conda activate samtools-1.14 && samtools coverage $i > $i.cov && conda deactivate ; done

6 Binning

L’assemblage de shorts reads issus de métagénomes shotguns permet rarement de reconstruire des génomes complets. Cependant le regroupement de contigs par binning permet de regrouper les séquences présentant des propriétés proches et est un bon compromis aux génomes complets. En effet, bien que fragmentés, ces ébauches de génomes sont souvent issues d’organismes proches. L’approche de binning qu’utilise MetaBAT2 [15] est basé sur la fréquence des tétranucléotides ainsi que les abondances des contigs en fonction des différents échantillons.

AstuceLancer metabat2 après avoir exploré les paramètres
Solution
mkdir BINNING
echo "conda activate metabat2-2.17 && jgi_summarize_bam_contig_depths --outputDepth BINNING/depth.txt --pairedContigs BINNING/paired.txt --minContigLength 500 --minContigDepth 2 MAPPING_ON_ASSEMBLY/*.bam && metabat2 -i MEGAHIT/final.contigs.fa -a BINNING/depth.txt -o BINNING/bin -m 1500 -v -t 4 --unbinned && conda deactivate" > metabat2.sh
qsub -cwd -V -q web.q -N metabat2 -pe thread 8 -o LOGS/ -e LOGS/ metabat2.sh

6.1 Évaluation des bins

Pour l’évaluation des bins, nous utiliserons les deux métriques completeness et contamination estimés par CheckM [16]. Cet outil utilise des sets de gènes marqueurs colocalisés qui sont ubiquitaires et présent en une seule copie au sein d’un taxon phylogénétique donné. Parmi la suite d’outils fourni par CheckM nous allons utiliser le workflow checkm2 predict qui est recommandé pour évaluer l’exhaustivité et la contamination des bins de génomes.

AstuceExécuter le workflow lineage-specific en spécifiant le dossier des bins
Solution
mkdir CHECKM/
echo "conda activate checkm2-1.1.0 && checkm2 predict --threads 8 --extension .fa --input BINNING/ --output-directory CHECKM/ && conda deactivate" > checkm.sh
qsub -cwd -V -q web.q -N checkm -pe thread 8 -o LOGS/ -e LOGS/ checkm.sh

Les résultats seront disponibles dans la table CHECKM/quality_report.tsv.

6.2 Taxonomie des bins

Pour assigner taxonomiquement nos bins, nous allons utiliser GTDB-Tk [17]. Cet outil utilise la base de données GTDB (Genome Taxonomy Database) qui est une base de référence pour la classification taxonomique des génomes de bactéries et archées.

AstuceLancer GTDB-Tk sur les bins
Solution
echo "conda activate gtdbtk-2.5.2 && gtdbtk classify_wf --genome_dir BINNING/ --out_dir GTDB/ --cpus 8 -x fa && conda deactivate" > gtdb.sh
qsub -cwd -V -q web.q -N gtdbtk -pe thread 8 -o LOGS/ -e LOGS/ gtdb.sh

7 Prédiction de gènes

A partir de contigs au format FASTA, bakta [18] permet d’annoter rapidement les séquences bactériennes, archéennes et virales (ainsi que les métagénomes avec l’option --metagenome). Il est basé sur une suite d’outils : prodigal [19] (détéction des gènes), RNAmmer [20] (rRNA), aragorn [21] (tRNA), signalP (Signal leader peptides) [22], infernal (Non-coding RNA) [23].

Si toutes les annotations ne sont pas désirées, il est possible de ne pas les faire.

AstuceLancer bakta
Solution
echo "conda activate bakta-1.12.0 && bakta MEGAHIT/final.contigs.fa --db /db/outils/bakta-1.12.0/db-light/ --min-contig-length 200 --output BAKTA/ --keep-contig-headers --threads 16 --force --verbose --skip-trna --skip-tmrna --skip-rrna --skip-ncrna --skip-ncrna-region --skip-crispr --skip-sorf --skip-gap --skip-ori --skip-filter --skip-plot --tmp-dir /projet/tmp/ && conda deactivate" > bakta.sh

qsub -cwd -V -q web.q -N bakta -o LOGS -e LOGS bakta.sh
AstuceRécupérer les comptages par CDS
  • Créer un répertoire MAPPING_ON_GENES
Solution
mkdir MAPPING_ON_GENES
  • Récupérer uniquement les features CDS dans le fichier d’annotation gff fourni par bakta
Solution
awk '$3 == "CDS"' BAKTA/final.contigs.gff3 > MAPPING_ON_GENES/cds.gff3
  • Utiliser le mapping sur les contigs pour en extraire avec htseq-count [24] les lecture s’alignant sur les CDS
Solution
echo "conda activate htseq-2.0.5 && htseq-count --with-header -f bam -t CDS -i ID MAPPING_ON_ASSEMBLY/*.bam MAPPING_ON_GENES/cds.gff3 > MAPPING_ON_GENES/genes.htseqcount && conda deactivate" > map_cds.sh

qsub -cwd -V -q web.q -N gene_count -o LOGS -e LOGS map_cds.sh

A partir de contigs au format FASTA, prokka [25] permet d’annoter rapidement les séquences bactériennes, archéennes et virales (ainsi que les métagénomes avec l’option --metagenome). Il est basé sur une suite d’outils : prodigal [19] (détéction des gènes), RNAmmer [20] (rRNA), aragorn [21] (tRNA), signalP (Signal leader peptides) [22], infernal (Non-coding RNA) [23].

AstuceLancer prokka
Solution
echo "conda activate prokka-1.14.6 && prokka --outdir PROKKA --addgenes --kingdom Bacteria --metagenome --cpus 8 MEGAHIT/final.contigs.fa && conda deactivate" > prokka.sh
qsub -cwd -V -q web.q -N prokka -o LOGS -e LOGS -pe thread 8 prokka.sh
AstuceRécupérer les comptages par gène
  • Créer un répertoire MAPPING_ON_GENES
Solution
mkdir MAPPING_ON_GENES
  • Récupérer uniquement les features gene dans le fichier d’annotation gff fourni par prokka
Solution
awk '$3 == "gene"' PROKKA/PROKKA_05212026.gff > MAPPING_ON_GENES/genes.gff
# awk '$3 == "gene"' PROKKA/PROKKA_*.gff > MAPPING_ON_GENES/genes.gff
  • Utiliser le mapping sur les contigs pour en extraire avec htseq-count [24] les lecture s’alignant sur les gènes
Solution
echo "conda activate htseq-2.0.5 && htseq-count --with-header -f bam -t gene -i locus_tag MAPPING_ON_ASSEMBLY/*.bam MAPPING_ON_GENES/genes.gff > MAPPING_ON_GENES/genes.htseqcount && conda deactivate" > map_genes.sh

qsub -cwd -V -q web.q -N gene_count -o LOGS -e LOGS map_genes.sh

8 Annotation fonctionnelle sur les gènes

L’objectif de cette étape est d’annoter fonctionellement les gènes codant pour des protéines, à différente niveau de finesse et avec des ontologies ou des hiérarchies fonctionelles permettant l’aggrégation des annotations sur différents niveaux.

8.1 Annotation sur des cluster d’orthologues pré-calculés (egg-nog)

eggnog-mapper [26] est un outil d’annotation fonctionnelle. Il utilise les groupes de proteines orthologues et les phylogénies précalculées de la base eggNOG comme référnce pour transférer les annotations fonctionelles d’orthologues soigneusement identifiées.

AstuceLancer eggnog-mapper
Solution
mkdir EGGNOG

conda activate seqkit-2.9.0 && seqkit split2 -p 20 BAKTA/final.contigs.faa -O split/ && conda deactivate



for f in split/*.faa; do echo "conda activate eggnog-mapper-2.1.13 && emapper.py -m diamond -d bact --no_annot --data_dir /db/outils/eggnog-mapper-2.1.13/ --no_file_comments --cpu 16 -i $f -o $f && conda deactivate" >> eggnog1.sh ; done

qarray -cwd -V -q web.q -o LOGS -e LOGS -N eggnog1 -pe thread 16 eggnog1.sh

cat split/*.emapper.seed_orthologs > EGGNOG/emapper.seed_orthologs

echo "conda activate eggnog-mapper-2.1.13 && emapper.py --annotate_hits_table EGGNOG/emapper.seed_orthologs --no_file_comments -o EGGNOG/eggnog --cpu 16 && conda deactivate" > eggnog2.sh

qsub -cwd -V -q web.q -N eggnog2 -o LOGS -e LOGS -pe thread 16 eggnog2.sh


##
## echo "conda activate eggnog-mapper-2.1.13 && emapper.py -i BAKTA/final.contigs.faa --output eggnog -m diamond -d bact --cpu 8 --data_dir /db/outils/eggnog-mapper-2.1.13/ --output_dir EGGNOG && conda deactivate" > eggnog.sh
## qsub -cwd -V -q web.q -N eggnog -o LOGS -e LOGS -pe thread 8 eggnog.sh

8.2 Annotation par similarité

Diamond [27] est un outil similaire à blast mais avec des heuristiques accélerant très fortement les comparaisons des gros jeux de données contre des banques.

AstuceLancer diamond
Solution
mkdir DIAMOND
echo "conda activate diamond-2.1.23 && diamond blastp --db /db/outils/diamond-0.9.26/nr.dmnd --out DIAMOND/diamond.out --outfmt 6 --threads 8 --query BAKTA/final.contigs.faa && conda deactivate" > diamond.sh
qsub -cwd -V -q web.q -N diamond -o LOGS -e LOGS -pe thread 8 diamond.sh

9 Flowchart

---
config:
  layout: dagre
---
flowchart TD
    %% Configuration des styles généraux
    classDef step fill:#f9f9f9,stroke:#333,stroke-width:2px,font-weight:bold;
    classDef tool fill:#e1f5fe,stroke:#0288d1,stroke-width:1px,font-style:italic;
    classDef file fill:#e8f5e9,stroke:#2e7d32,stroke-width:1px,font-family:monospace;

    %% Étape 1: Contrôle Qualité
    subgraph ST1 [Contrôle Qualité]
        direction TB
        sk[seqkit]
        fqc[FastQC] --> mqc[MultiQC]
    end
    class ST1 step; class sk,fqc,mqc tool;
    ST1 --> F_CLEANING([TSV / HTML])
    class F_CLEANING file;

    F_RAW([FASTQ raw]) --> ST1
    class F_RAW file;

    %% Étape 1.5: Assignation taxonomique
    subgraph ST15 [Assignation taxonomique]
        direction TB
        subgraph STT1 [tools]
        direction LR
            kj[kaiju] --- kra[kraken] 
        end
        STT1 --> kr[krona]
    end
    class ST15 step; class kj,kra,kr tool;
    F_RAW([FASTQ raw]) --> ST15
    ST15 --> F_TAX([TSV / HTML])
    class F_TAX file;

    %% Étape 3: Nettoyage
    subgraph ST3 [Nettoyage]
        direction TB
        fp[fastp] --> hocort[Hocort]
    end
    class ST3 step; class fp,smr,hocort,st tool;

    F_RAW --> ST3
    ST3 --> F_CLEAN([FASTQ cleaned])
    class F_CLEAN file;

    %% Étape 4: Assemblage
    subgraph ST4 [Assemblage]
        subgraph ST4t [tools]
        direction TB
        mh[megahit] --- mspad[metaspades]
        end
        direction LR
        ST4t --> qt[quast]
        ST4t --> sk2[seqkit]
    end
    class ST4 step; class mh,qt,mspad,sk2 tool;

    F_CLEAN --> ST4
    ST4 --> F_ASM([FASTA Contigs])
    class F_ASM file;

    %% Étape 5: Mapping
    subgraph ST5 [Mapping]
        direction TB
        mp[bwa] --> smt[samtools]
    end
    class ST5 step; class mp,smt tool;

    F_CLEAN --> ST5
    F_ASM --> ST5
    ST5 --> F_BAM([BAM])
    class F_BAM file;

    %% Étape 6: Binning
    subgraph ST6 [Binning]
        direction LR
        mb[metabat2] --> cm[checkm]
    end
    class ST6 step; class mb,cm tool;

    F_ASM --> ST6
    F_BAM --> ST6
    ST6 --> F_BINS([FASTA MAGs / Bins])
    class F_BINS file;

    %% Étape 7: Prédiction de gènes
    subgraph ST7 [Prédiction de gènes]
        direction TB
        pk[bakta] --> hts[htseq-count]
    end
    class ST7 step; class pk,hts tool;

    F_ASM --> ST7
    ST7 --> F_GENES_FAA([FASTA prot])
    ST7 --> F_GENES_GFF([GFF])
    ST7 --> F_GENES_TSV([TSV])
    class F_GENES_FAA,F_GENES_GFF,F_GENES_TSV file;

    %% Étape 8: Annotation fonctionnelle
    subgraph ST8 [Annotation fonctionnelle]
        direction LR
        dm[diamond] --- em[eggnog-mapper]
    end
    class ST8 step; class dm,em tool;

    F_GENES_FAA --> ST8
    ST8 --> F_ANNOT([TSV GFF Annotations])
    class F_ANNOT file;
    
    F_RAW@{ shape: docs}
    F_CLEAN@{ shape: docs}
    F_BAM@{ shape: docs}
    F_BINS@{ shape: docs}

Les références

1. Shen W, Le S, Li Y, Hu F. SeqKit: a cross-platform and ultrafast toolkit for FASTA/Q file manipulation. PloS one. 2016;11:e0163962.
2. Andrews S. FastQC A Quality Control tool for High Throughput Sequence Data. http://www.bioinformatics.babraham.ac.uk/projects/fastqc/. 2010. http://www.bioinformatics.babraham.ac.uk/projects/fastqc/.
3. Ewels P, Magnusson M, Lundin S, Käller M. MultiQC: summarize analysis results for multiple tools and samples in a single report. Bioinformatics. 2016;32:3047‑8.
4. Wood DE, Salzberg SL. Kraken: ultrafast metagenomic sequence classification using exact alignments. Genome biology. 2014;15:1‑12.
5. Ondov BD, Bergman NH, Phillippy AM. Interactive metagenomic visualization in a Web browser. BMC bioinformatics. 2011;12:385.
6. Menzel P, Ng KL, Krogh A. Fast and sensitive taxonomic classification for metagenomics with Kaiju. Nature communications. 2016;7:11257.
7. Zhou Y, Chen Y, Chen S, Gu J. fastp: an ultra-fast all-in-one FASTQ preprocessor. Bioinformatics. 2018;34:i884‑90. doi:10.1093/bioinformatics/bty560.
8. Rumbavicius I, Rounge TB, Rognes T. HoCoRT: host contamination removal tool. BMC bioinformatics. 2023;24:371.
9. Li H. Aligning sequence reads, clone sequences and assembly contigs with BWA-MEM. arXiv preprint arXiv:13033997. 2013.
10. Quinlan AR, Hall IM. BEDTools: a flexible suite of utilities for comparing genomic features. Bioinformatics. 2010;26:841‑2.
11. Li D, Liu C-M, Luo R, Sadakane K, Lam T-W. MEGAHIT: an ultra-fast single-node solution for large and complex metagenomics assembly via succinct de Bruijn graph. Bioinformatics. 2015;31:1674‑6.
12. Bankevich A, Nurk S, Antipov D, Gurevich AA, Dvorkin M, Kulikov AS, et al. SPAdes: A New Genome Assembly Algorithm and Its Applications to Single-Cell Sequencing. Journal of Computational Biology. 2012;19:455‑77. doi:10.1089/cmb.2012.0021.
13. Mikheenko A, Prjibelski A, Saveliev V, Antipov D, Gurevich A. Versatile genome assembly evaluation with QUAST-LG. Bioinformatics. 2018;34:i142‑50. doi:10.1093/bioinformatics/bty266.
14. Li H, Handsaker B, Wysoker A, Fennell T, Ruan J, Homer N, et al. The sequence alignment/map format and SAMtools. Bioinformatics. 2009;25:2078‑9.
15. Kang DD, Froula J, Egan R, Wang Z. MetaBAT, an efficient tool for accurately reconstructing single genomes from complex microbial communities. PeerJ. 2015;3:e1165.
16. Parks DH, Imelfort M, Skennerton CT, Hugenholtz P, Tyson GW. CheckM: assessing the quality of microbial genomes recovered from isolates, single cells, and metagenomes. Genome Research. 2015;25:1043‑55. doi:10.1101/gr.186072.114.
17. Chaumeil P-A, Mussig AJ, Hugenholtz P, Parks DH. GTDB-Tk v2: memory friendly classification with the genome taxonomy database. Bioinformatics. 2022;38:5315‑6.
18. Schwengers O, Jelonek L, Dieckmann MA, Beyvers S, Blom J, Goesmann A. Bakta: rapid and standardized annotation of bacterial genomes via alignment-free sequence identification. Microbial Genomics. 2021;7. doi:https://doi.org/10.1099/mgen.0.000685.
19. Hyatt D, Chen G-L, LoCascio PF, Land ML, Larimer FW, Hauser LJ. Prodigal: prokaryotic gene recognition and translation initiation site identification. BMC bioinformatics. 2010;11:1‑11.
20. Lagesen K, Hallin P, Rødland EA, Stærfeldt H-H, Rognes T, Ussery DW. RNAmmer: consistent and rapid annotation of ribosomal RNA genes. Nucleic acids research. 2007;35:3100‑8.
21. Laslett D, Canback B. ARAGORN, a program to detect tRNA genes and tmRNA genes in nucleotide sequences. Nucleic acids research. 2004;32:11‑6.
22. Petersen TN, Brunak S, Von Heijne G, Nielsen H. SignalP 4.0: discriminating signal peptides from transmembrane regions. Nature methods. 2011;8:785‑6.
23. Nawrocki EP, Kolbe DL, Eddy SR. Infernal 1.0: inference of RNA alignments. Bioinformatics. 2009;25:1335‑7.
24. Anders S, Pyl PT, Huber W. HTSeq—a Python framework to work with high-throughput sequencing data. bioinformatics. 2015;31:166‑9.
25. Seemann T. Prokka: rapid prokaryotic genome annotation. Bioinformatics. 2014;30:2068‑9. doi:10.1093/bioinformatics/btu153.
26. Cantalapiedra CP, Hernández-Plaza A, Letunic I, Bork P, Huerta-Cepas J. eggNOG-mapper v2: functional annotation, orthology assignments, and domain prediction at the metagenomic scale. Molecular biology and evolution. 2021;38:5825‑9.
27. Buchfink B, Xie C, Huson DH. Fast and sensitive protein alignment using DIAMOND. Nature Methods. 2014;12:59‑60. doi:10.1038/nmeth.3176.

Réutilisation


A work by Migale Bioinformatics Facility
Université Paris-Saclay, INRAE, MaIAGE, 78350, Jouy-en-Josas, France
Université Paris-Saclay, INRAE, BioinfOmics, MIGALE bioinformatics facility, 78350, Jouy-en-Josas, France