dorado
0.8.2
Dorado est un appelant de base open source hautes performances et facile à utiliser pour les lectures Oxford Nanopore.
Un exécutable avec des valeurs par défaut sensibles, une détection et une configuration automatiques du matériel.
Fonctionne sur du silicium Apple (famille M1/2) et des GPU Nvidia, y compris multi-GPU avec mise à l'échelle linéaire (voir Plateformes).
Appel de base modifié.
Appel de base duplex (regardez la vidéo suivante pour une introduction à Duplex).
Classification des codes-barres simplex.
Prise en charge de la sortie de lecture alignée dans SAM/BAM.
Prise en charge initiale de l'estimation de la queue poly(A).
Prise en charge de la correction d'erreur en lecture unique.
Prise en charge du POD5 pour des performances d'appel de base les plus élevées.
Basé sur libtorch, l'API C++ pour pytorch.
Plusieurs optimisations personnalisées dans CUDA et Metal pour maximiser les performances d'inférence.
Si vous rencontrez des problèmes pour créer ou exécuter Dorado, veuillez signaler un problème.
Tout d’abord, téléchargez le programme d’installation correspondant à votre plateforme :
dorado-0.8.2-linux-x64
dorado-0.8.2-linux-arm64
dorado-0.8.2-osx-arm64
dorado-0.8.2-win64
Une fois l'archive .tar.gz ou .zip correspondante téléchargée, extrayez l'archive à l'emplacement souhaité.
Vous pouvez ensuite appeler Dorado en utilisant le chemin complet, par exemple :
$ /path/to/dorado-x.y.z-linux-x64/bin/dorado basecaller hac pod5s/ > calls.bam
Ou vous pouvez ajouter le chemin bin à votre variable d'environnement $PATH et exécuter à la place la commande dorado , par exemple :
$ dorado basecaller hac pod5s/ > calls.bam
Voir DEV.md pour plus de détails sur la création de Dorado pour le développement.
Dorado est fortement optimisé pour les GPU Nvidia A100 et H100 et offrira des performances maximales sur les systèmes équipés de ces GPU.
Dorado a été largement testé et pris en charge sur les systèmes suivants :
| Plate-forme | GPU/CPU | Configuration logicielle minimale requise |
|---|---|---|
| Linuxx86_64 | (G)V100, A100 | Pilote CUDA ≥450.80.02 |
| H100 | Pilote CUDA ≥520 | |
| Linux arm64 | Jetson Orin | Linux pour Tegra ≥34.1.1 |
| Windows x86_64 | (G)V100, A100 | Pilote CUDA ≥452,39 |
| H100 | Pilote CUDA ≥520 | |
| Pomme | Apple Silicium (M1/M2) |
Les systèmes Linux ou Windows non répertoriés ci-dessus mais dotés de GPU Nvidia avec ≥8 Go de VRAM et une architecture à partir de Pascal (sauf P100/GP100) n'ont pas été largement testés mais devraient fonctionner. Lors des appels de base avec des appareils Apple, nous recommandons les systèmes dotés de ≥16 Go de mémoire unifiée.
Si vous rencontrez des problèmes d'exécution sur votre système, veuillez signaler un problème.
Les benchmarks AWS sur les GPU Nvidia pour Dorado 0.3.0 sont disponibles ici. Remarque : la vitesse d'appel de base de Dorado s'améliore continuellement, ces tests peuvent donc ne pas refléter les performances de la dernière version.
Pour des performances optimales, Dorado nécessite une entrée de fichier POD5. Veuillez convertir vos fichiers .fast5 avant l'appel de base.
Dorado détectera automatiquement la mémoire libre de votre GPU et sélectionnera une taille de lot appropriée.
Dorado s'exécutera automatiquement en mode cuda:all multi-GPU. Si vous disposez d'une collection hétérogène de GPU, sélectionnez les GPU les plus rapides à l'aide de l'indicateur --device (par exemple --device cuda:0,2 ). Ne pas le faire aura un impact négatif sur les performances.
Les commandes suivantes sont utiles pour démarrer avec Dorado. Pour voir toutes les options et leurs valeurs par défaut, exécutez dorado -h et dorado <subcommand> -h .
Dorado peut sélectionner automatiquement un modèle d'appel de base en utilisant une sélection de vitesse de modèle ( fast , hac , sup ) et les données pod5. Cette fonctionnalité n'est pas prise en charge pour les données fast5. Si le modèle n'existe pas localement, Dorado téléchargera automatiquement le modèle et l'utilisera.
Dorado continue de prendre en charge les chemins de modèles.
Pour plus de détails, lisez Complexe de sélection automatique de modèle.
Pour exécuter le basecalling Dorado, en utilisant le modèle hac téléchargé automatiquement sur un répertoire de fichiers POD5 ou un seul fichier POD5 (les fichiers .fast5 sont pris en charge, mais ne seront pas aussi performants) .
$ dorado basecaller hac pod5s/ > calls.bam
Pour appeler un seul fichier, remplacez simplement le répertoire pod5s/ par un chemin d'accès à votre fichier de données.
Si le basecalling est interrompu, il est possible de reprendre le basecalling à partir d'un fichier BAM. Pour ce faire, utilisez l'indicateur --resume-from pour spécifier le chemin d'accès au fichier BAM incomplet. Par exemple:
$ dorado basecaller hac pod5s/ --resume-from incomplete.bam > calls.bam
calls.bam contiendra toutes les lectures de incomplete.bam ainsi que les nouveaux appels de base ( incomplete.bam peut être supprimé une fois l'appel de base terminé) .
Remarque : il est important de choisir un nom de fichier différent pour le fichier BAM dans lequel vous écrivez lorsque vous utilisez --resume-from . Si vous utilisez le même nom de fichier, le fichier BAM interrompu perdra les appels de base existants et l'appel de base redémarrera depuis le début.
Dorado peut détecter et supprimer toutes les séquences d’adaptateur et/ou d’amorce du début et de la fin des lectures d’ADN. Notez que si vous avez l'intention de démultiplexer les lectures ultérieurement, le découpage des adaptateurs et des amorces peut entraîner la suppression de certaines parties des régions adjacentes des codes-barres, ce qui pourrait interférer avec un démultiplexage correct.
Par défaut, dorado basecaller tentera de détecter toutes les séquences d'adaptateur ou d'amorce au début et à la fin des lectures, et de les supprimer de la séquence de sortie.
Cette fonctionnalité peut être modifiée en utilisant les options --trim ou --no-trim avec dorado basecaller . L'option --no-trim empêchera le découpage des séquences de codes-barres détectées ainsi que la détection et le découpage des séquences d'adaptateur et d'amorce.
L'option --trim prend comme argument l'une des valeurs suivantes :
all C'est le même que le comportement par défaut. Tous les adaptateurs ou amorces détectés seront tronqués, et si le code-barres est activé, tous les codes-barres détectés seront tronqués.
primers Cela entraînera la suppression de tous les adaptateurs ou amorces détectés, mais si le codage à barres est activé, les séquences de codes à barres ne seront pas supprimées.
adapters Cela entraînera la suppression de tous les adaptateurs détectés, mais les amorces ne seront pas coupées, et si le code-barres est activé, les codes-barres ne seront pas non plus coupés.
none Cela revient à utiliser l'option --no-trim. Rien ne sera coupé.
Si le découpage des adaptateurs/amorces est effectué en ligne avec l'appel de base en combinaison avec le démultiplexage, alors le logiciel garantira automatiquement que le découpage des adaptateurs et des amorces n'interfère pas avec le processus de démultiplexage. Cependant, si vous avez l'intention d'effectuer le démultiplexage ultérieurement dans le cadre d'une étape distincte, il est recommandé de désactiver le découpage de l'adaptateur/amorce lors de l'appel de base avec l'option --no-trim , pour garantir que toutes les séquences de codes-barres restent complètement intactes dans les lectures.
Les ensembles de données de base existants peuvent être analysés à la recherche de séquences d'adaptateur et/ou d'amorce à chaque extrémité, et supprimer toutes ces séquences trouvées. Pour ce faire, exécutez :
$ dorado trim <reads> > trimmed.bam
<reads> peut être soit un fichier au format HTS (par exemple FASTQ, BAM, etc.) soit un flux au format HTS (par exemple la sortie de Dorado basecalling).
L'option --no-trim-primers peut être utilisée pour empêcher le découpage des séquences d'amorces. Dans ce cas, seules les séquences d'adaptateurs seront tronquées.
Si vous avez également l'intention de démultiplexer les données, il est recommandé de démultiplexer avant de découper les adaptateurs et les amorces, car le découpage préalable des adaptateurs et des amorces peut interférer avec la classification correcte des codes-barres.
La sortie de dorado trim sera toujours des enregistrements non alignés, que l'entrée soit alignée/triée ou non.
Le logiciel recherche automatiquement les séquences d'amorces utilisées dans les kits Oxford Nanopore. Cependant, vous pouvez spécifier un autre ensemble de séquences d'amorces à rechercher lors du découpage, soit en ligne avec l'appel de base, soit en combinaison avec l'option --trim . Dans les deux cas, cela est accompli en utilisant l'option de ligne de commande --primer-sequences , suivie du chemin complet et du nom d'un fichier FASTA contenant les séquences d'amorces que vous souhaitez rechercher. Les noms d'enregistrement des séquences n'ont pas d'importance. Notez que si vous utilisez cette option, les séquences d'amorces normales intégrées au logiciel Dorado ne seront pas recherchées.
Les adaptateurs pour les kits RNA002 et RNA004 sont automatiquement coupés pendant l'appel de base. Cependant, contrairement à l’ADN, l’adaptateur d’ARN ne peut pas être coupé après l’appel de base.
Au-delà des noms de base traditionnels A, T, C et G, Dorado peut également détecter des bases modifiées telles que la 5-méthylcytosine (5 mC), la 5-hydroxyméthylcytosine (5hmC) et la N 6 -méthyladénosine (6 mA). Ces bases modifiées jouent un rôle crucial dans la régulation épigénétique.
Pour appeler des modifications, étendez l'argument models avec une liste de modifications séparées par des virgules :
$ dorado basecaller hac,5mCG_5hmCG,6mA pod5s/ > calls.bam
Dans l'exemple ci-dessus, l'appel de base est effectué avec la détection à la fois de 5 mC/5hmC dans les contextes CG et de 6 mA dans tous les contextes.
Reportez-vous à la colonne Modifications compatibles du tableau des modèles ADN pour voir les modifications disponibles qui peuvent être appelées avec l'option --modified-bases .
Les appels de base modifiés sont également pris en charge avec les appels de base Duplex, où ils produisent des appels d'hémi-méthylation.
Pour exécuter l'appel de base Duplex, exécutez la commande :
$ dorado duplex sup pod5s/ > duplex.bam
Lors de l'utilisation de la commande duplex , deux types de résultats de séquence d'ADN seront produits : « simplex » et « duplex ». Toute position spécifique dans l'ADN qui se trouve dans une lecture duplex est également visible dans deux brins simplex (la matrice et le complément). Ainsi, chaque position d'ADN séquencée en duplex sera couverte par un minimum de trois lectures distinctes dans le résultat.
La balise dx dans l'enregistrement BAM pour chaque lecture peut être utilisée pour faire la distinction entre les lectures simplex et duplex :
dx:i:1 pour les lectures recto verso.
dx:i:0 pour les lectures simplex qui n'ont pas de descendants duplex.
dx:i:-1 pour les lectures simplex qui ont des descendants duplex.
Dorado rapportera le taux de duplex comme le nombre de nucléotides dans les appels de base duplex multiplié par deux et divisé par le nombre total de nucléotides dans les appels de base simplex. Cette valeur est une approximation étroite de la proportion de nucléotides ayant participé à un appel de base duplex.
L'appel de base duplex peut être effectué avec une détection de base modifiée, produisant des appels d'hémi-méthylation pour les lectures duplex :
$ dorado duplex hac,5mCG_5hmCG pod5s/ > duplex.bam
Plus d'informations sur la façon dont les appels d'hémi-méthylation sont représentés peuvent être trouvées à la page 7 du document de spécification SAM (version aa7440d) et dans la documentation Modkit.
Dorado prend en charge l’alignement des appels de base existants ou la production directe d’une sortie alignée.
Pour aligner les références de base existantes, exécutez :
$ dorado aligner <index> <reads> > aligned.bam
où index est une référence sur laquelle s'aligner au format (FASTQ/FASTA/.mmi) et reads est un dossier ou un fichier dans n'importe quel format HTS.
Lors de la lecture à partir d'un dossier d'entrée, dorado aligner prend également en charge l'émission de fichiers alignés vers un dossier de sortie, ce qui préservera la structure des fichiers des entrées :
$ dorado aligner <index> <input_read_folder> --output-dir <output_read_folder>
Un résumé d'alignement contenant des statistiques d'alignement pour chaque lecture peut être généré avec l'option --emit-summary . Le fichier sera enregistré dans le dossier --output-dir .
Pour effectuer un appel de base avec alignement avec duplex ou simplex, exécutez avec l'option --reference :
$ dorado basecaller <model> <reads> --reference <index> > calls.bam
L'alignement utilise minimap2 et utilise par défaut le préréglage lr:hq . Cela peut être remplacé en passant une chaîne d'option de mini-carte, --mm2-opts , en utilisant l'option '-x' et/ou des options individuelles telles que -k et -w pour définir respectivement le kmer et la taille de la fenêtre. Pour une liste complète des options minimap2 prises en charge, utilisez '--mm2-opts --help'. Par exemple:
$ dorado aligner <index> <input_read_folder> --output-dir <output_read_folder> --mm2-opt "-x splice --junc-bed <annotations_file>" $ dorado aligner <index> <input_read_folder> --output-dir <output_read_folder> --mm2-opt --help $ dorado basecaller <model> <reads> --reference <index> --mm2-opt "-k 15 -w 10" > calls.bam
La commande dorado summary génère un fichier séparé par des tabulations avec des informations de séquençage de niveau de lecture à partir du fichier BAM généré lors de l'appel de base. Pour créer un résumé, exécutez :
$ dorado summary <bam> > summary.tsv
Notez que la génération de résumé n'est disponible que pour les lectures de base appelées à partir de fichiers POD5. Les lectures de base appelées à partir de fichiers .fast5 ne sont pas compatibles avec la commande summary.
Dorado prend en charge la classification des codes-barres pour les appels de base existants ainsi que la production directe de appels de base classifiés.
Dans ce mode, les lectures sont classées dans leurs groupes de codes-barres lors de l'appel de base dans le cadre de la même commande. Pour activer cela, exécutez :
$ dorado basecaller <model> <reads> --kit-name <barcode-kit-name> > calls.bam
Cela se traduira par un flux de sortie unique avec des lectures classifiées. La classification sera reflétée dans le nom du groupe de lecture ainsi que dans la balise BC de l'enregistrement de sortie.
Par défaut, Dorado est configuré pour supprimer le code-barres des lectures. Pour désactiver le découpage, ajoutez --no-trim à la ligne de commande.
L'heuristique par défaut pour les codes-barres à double extrémité consiste à les rechercher à chaque extrémité de la lecture. Cela entraîne un taux de classification plus élevé, mais peut également entraîner un nombre de faux positifs plus élevé. Pour résoudre ce problème, dorado basecaller fournit également une option --barcode-both-ends pour forcer la détection des codes-barres à double extrémité aux deux extrémités avant la classification. Cela réduira considérablement les faux positifs, mais réduira également les taux de classification globaux.
La sortie de dorado basecaller peut être démultiplexée en BAM par code-barres à l'aide de dorado demux . par exemple
$ dorado demux --output-dir <output-dir> --no-classify <input-bam>
Cela générera un fichier BAM par code-barres dans le output-dir .
Les informations du code-barres sont également reflétées dans l'en-tête BAM RG . Par conséquent, le démultiplexage est également possible via samtools split . par exemple
$ samtools split -u <output-dir>/unclassified.bam -f "<output-dir>/<prefix>_%!.bam" <input-bam>
Cependant, samtools split utilise la chaîne RG complète comme suffixe du nom de fichier, ce qui peut entraîner des noms de fichiers très longs. Nous vous recommandons d'utiliser dorado demux pour diviser les BAM à codes-barres.
Les ensembles de données de base existants peuvent être classés et démultiplexés en BAM par code-barres à l'aide de la commande demux autonome dans dorado . Pour l'utiliser, exécutez
$ dorado demux --kit-name <kit-name> --output-dir <output-folder-for-demuxed-bams> <reads>
<reads> peut être soit un dossier, soit un fichier unique au format HTS (par exemple FASTQ, BAM, etc.) ou un flux au format HTS (par exemple la sortie de Dorado Basecalling).
Cela entraîne la génération de plusieurs fichiers BAM dans le dossier de sortie, un par code-barres (formaté comme KITNAME_BARCODEXX.bam ) et un pour toutes les lectures non classifiées. Comme pour le mode en ligne, --no-trim et --barcode-both-ends sont également disponibles comme options supplémentaires.
Si le fichier d'entrée est aligné/trié et que --no-trim est choisi, chacun des fichiers BAM spécifiques au code-barres de sortie sera également trié et indexé. Cependant, si le découpage est activé (ce qui est la valeur par défaut), les informations d'alignement sont supprimées et les BAM de sortie ne sont pas alignés. Ceci est dû au fait que les balises d'alignement et les positions sont invalidées une fois qu'une séquence est modifiée.
Voici un exemple de dossier de sortie
$ dorado demux --kit-name SQK-RPB004 --output-dir /tmp/demux reads.fastq $ ls -1 /tmp/demux SQK-RPB004_barcode01.bam SQK-RPB004_barcode02.bam SQK-RPB004_barcode03.bam ... unclassified.bam
Un fichier récapitulatif répertoriant chaque lecture et son code-barres classé peut être généré avec l'option --emit-summary dans dorado demux . Le fichier sera enregistré dans le dossier --output-dir .
Si les fichiers de données d'entrée contiennent des données de mappage, ces informations peuvent être conservées dans les fichiers de sortie. Pour ce faire, vous devez utiliser l'option --no-trim . Couper les codes-barres invalidera toutes les informations de mappage pouvant être contenues dans les fichiers d'entrée et, par conséquent, l'application exclura toute information de mappage si --no-trim n'est pas spécifié.
Il est également possible de demander à dorado demux de trier et d'indexer tous les fichiers bam de sortie contenant des lectures mappées. Pour activer cela, utilisez l'option --sort-bam . Si vous utilisez cette option, vous devez également utiliser l'option --no-trim , car le découpage empêchera toute information de mappage d'être incluse dans les fichiers de sortie. Les fichiers d'index (extension .bai) seront créés uniquement pour les fichiers BAM contenant des lectures mappées et qui ont été triés. Notez que pour les grands ensembles de données, le tri des fichiers de sortie peut prendre quelques minutes.
Dorado est capable d'utiliser une feuille d'échantillon pour restreindre les classifications de codes-barres à celles présentes uniquement et d'appliquer des alias aux classifications détectées. Ceci est activé en transmettant le chemin d'accès à une feuille d'échantillon à l'argument --sample-sheet lors de l'utilisation des commandes basecaller ou demux . Voir ici pour plus d'informations.
En plus de prendre en charge les kits de codes-barres standard d'Oxford Nanopore, Dorado prend également en charge la spécification d'arrangements et de séquences de kits de codes-barres personnalisés. Cela se fait en transmettant un fichier d'arrangement de codes-barres via l'argument --barcode-arrangement (soit à dorado demux , soit dorado basecaller ). Des séquences de codes-barres personnalisées peuvent éventuellement être spécifiées via l'option --barcode-sequences . Voir ici pour plus de détails.
Dorado dispose d'un support initial pour estimer la longueur des queues poly(A) pour l'ADNc (kits PCS et PCB) et l'ARN. Notez que les lectures d’ADNc d’Oxford Nanopore sont séquencées dans deux orientations différentes et que l’estimation de la longueur de la queue du poly(A) Dorado gère les deux (homopolymères A et T). Cette fonctionnalité peut être activée en passant --estimate-poly-a à la commande basecaller . Il est désactivé par défaut. La longueur estimée de la queue est stockée dans la balise pt:i de l'enregistrement de sortie. Les lectures pour lesquelles la longueur de la queue n'a pas pu être estimée n'auront pas la balise pt:i . Les séquences d'amorces personnalisées et l'estimation des queues interrompues peuvent être configurées via l'option --poly-a-config . Voir ici pour plus de détails.
Dorado prend en charge la correction d'erreurs en lecture unique avec l'intégration de l'algorithme HERRO. HERRO utilise un alignement tout contre tout suivi d'une correction tenant compte des haplotypes à l'aide d'un modèle d'apprentissage en profondeur pour obtenir des précisions de lecture unique plus élevées. Les lectures corrigées sont principalement utiles pour générer des assemblages de novo d’organismes diploïdes.
Pour corriger les lectures, exécutez :
$ dorado correct reads.fastq > corrected_reads.fasta
Dorado correct ne prend en charge que FASTQ (.gz) en entrée et génère un fichier FASTA en sortie. L'entrée peut être décompressée ou compressée avec bgz . Un fichier d'index est généré pour le fichier FASTQ d'entrée dans le même dossier, sauf si un fichier est déjà présent. Veuillez vous assurer que le dossier contenant le fichier d'entrée est accessible en écriture par le processus dorado et dispose de suffisamment d'espace disque.
L’outil de correction d’erreurs est à la fois gourmand en calcul et en mémoire. En conséquence, il est préférable de l'exécuter sur un système doté de plusieurs cœurs de processeur hautes performances (>= 64 cœurs), d'une grande mémoire système (>= 256 Go) et d'un GPU moderne avec une grande VRAM (>= 32 Go).
Tous les poids de modèle requis sont téléchargés automatiquement par Dorado. Cependant, les poids peuvent également être pré-téléchargés et transmis via la ligne de commande en cas d'exécution hors ligne. Pour ce faire, exécutez :
$ dorado download --model herro-v1 $ dorado correct -m herro-v1 reads.fastq > corrected_reads.fasta
Dorado Correct fournit désormais également une fonctionnalité permettant d'exécuter le mappage (étape CPU uniquement) et l'inférence (étape gourmande en GPU) individuellement. Cela permet de séparer les étapes lourdes du CPU et du GPU en étapes individuelles qui peuvent même être exécutées sur différents nœuds dotés de caractéristiques de calcul appropriées. Exemple:
$ dorado correct reads.fastq --to-paf > overlaps.paf $ dorado correct reads.fastq --from-paf overlaps.paf > corrected_reads.fasta
Le PAF compressé n'est actuellement pas pris en charge pour l'option --from-paf .
De plus, si une exécution a été arrêtée ou a échoué, Dorado Correct fournit une fonctionnalité de « reprise ». La fonction de reprise prend une liste de lectures précédemment corrigées (par exemple un index .fai de l'exécution précédente) et ignore les lectures précédemment traitées :
$ samtools faidx corrected_reads.1.fasta # Output from the previously interrupted run. $ dorado correct reads.fastq --resume-from corrected_reads.1.fasta.fai > corrected_reads.2.fasta
Le format de fichier d'entrée pour la fonctionnalité --resume-from peut être n'importe quel fichier texte brut dans lequel la première colonne délimitée par des espaces (ou une ligne complète) est constituée de noms de séquence à ignorer, un par ligne.
Si le processus consomme trop de mémoire pour votre système, essayez de l'exécuter avec une taille d'index plus petite. Par exemple:
$ dorado correct reads.fastq --index-size 4G > corrected_reads.fasta
La taille du lot d'inférence calculée automatiquement est peut-être encore trop élevée pour votre système. Si vous rencontrez des avertissements/erreurs concernant la mémoire GPU disponible, essayez de réduire la taille du lot/de la sélectionner manuellement. Par exemple:
$ dorado correct reads.fastq --batch-size <number> > corrected_reads.fasta
Si votre fichier FASTA de sortie contient un très faible nombre de lectures corrigées par rapport à l'entrée, veuillez vérifier les points suivants :
L'ensemble de données d'entrée a une longueur de lecture moyenne >=10kbp . Dorado Correct est conçu pour les lectures longues et ne fonctionnera pas sur les bibliothèques courtes.
La couverture d'entrée est raisonnable, de préférence >=30x .
Vérifiez les qualités de base moyennes de l'ensemble de données d'entrée. Dorado Correct attend des entrées précises pour la cartographie et l'inférence.
Pour télécharger tous les modèles Dorado disponibles, exécutez :
$ dorado download --model all
Les noms des modèles Dorado sont systématiquement structurés, chaque segment correspondant à un aspect différent du modèle, qui inclut à la fois la chimie et les paramètres d'exécution. Vous trouverez ci-dessous un exemple de nom de modèle expliqué :
Type d'analyte ( dna ) : Ceci indique le type d'analyte séquencé. Pour le séquençage de l’ADN, il est représenté par dna . Si vous utilisez un kit de séquençage direct d’ARN, ce sera rna002 ou rna004 , selon le kit.
Type de pores ( r10.4.1 ) : Cette section correspond au type de Flow Cell utilisé. Par exemple, FLO-MIN114/FLO-FLG114 est indiqué par r10.4.1 , tandis que FLO-MIN106D/FLO-FLG001 est indiqué par r9.4.1 .
Type de chimie ( e8.2 ) : Ceci représente le type de chimie, qui correspond au kit utilisé pour le séquençage. Par exemple, la chimie du kit 14 est désignée par e8.2 et le kit 10 ou le kit 9 sont désignés par e8 .
Vitesse de translocation ( 400bps ) : Ce paramètre, sélectionné lors de la configuration de l'exécution dans MinKNOW, fait référence à la vitesse de translocation. Avant de commencer votre exécution, une invite vous demandera si vous préférez exécuter à 260 bps ou 400 bps. Le premier donne des résultats plus précis mais fournit moins de données. Depuis la version 23.04 de MinKNOW, l'option 260 bps est obsolète.
Type de modèle ( hac ) : cela représente la taille du modèle, où les modèles plus grands donnent des appels de base plus précis mais prennent plus de temps. Les trois types de modèles sont fast , hac et sup . Le modèle fast est le plus rapide, sup est le plus précis et hac offre un équilibre entre vitesse et précision. Pour la plupart des utilisateurs, le modèle hac est recommandé.
Numéro de version du modèle ( v5.0.0 ) : indique la version du modèle. Des mises à jour de modèles sont régulièrement publiées et des numéros de version plus élevés signifient généralement une plus grande précision.
Vous trouverez ci-dessous un tableau des modèles d'appel de base disponibles et des modèles d'appel de base modifiés qui peuvent être utilisés avec eux. Les modèles en gras correspondent à la dernière condition publiée avec des données de 5 kHz.
Le versionnement des modèles de modification est lié au modèle d'appel de base. Cela signifie que la version du modèle de modification est réinitialisée pour chaque nouvelle version du modèle simplex. Par exemple, 6mA@v1 compatible avec les modèles d'appel de base v4.3.0 est plus récent que 6mA@v2 compatible avec les modèles d'appel de base v4.2.0 .
| Modèles de référence | Compatible Modifications | Modifications Modèle Version | Données Échantillonnage Fréquence |
|---|---|---|---|
| [email protected] | 5 kHz | ||
| [email protected] | 4mC_5mC 5mCG_5hmCG 5mC_5hmC 6 mA | v2 v2 v2 v2 | 5 kHz |
| [email protected] | 4mC_5mC 5mCG_5hmCG 5mC_5hmC 6 mA | v2 v2.0.1 v2.0.1 v2 | 5 kHz |
| [email protected] | 5 kHz | ||
| [email protected] | 5mCG_5hmCG 5mC_5hmC 6 mA | v1 v1 v2 | 5 kHz |
| [email protected] | 5mCG_5hmCG 5mC_5hmC 6mA | v1 v1 v2 | 5 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 5 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 5 kHz |
| [email protected] | 5mCG_5hmCG 5mC_5hmC 5mC 6 mA | v3.1 v1 v2 v3 | 5 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG_5hmCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 5mCG | v2 | 4 kHz |
| [email protected] | 4 kHz | ||
| [email protected] | 5mCG_5hmCG 5mCG | v0 v0.1 | 4 kHz |
| [email protected] | 5mCG_5hmCG 5mCG | v0 v0.1 | 4 kHz |
| [email protected] | 5mCG_5hmCG 5mCG | v0 v0.1 | 4 kHz |
Remarque : Le format BAM ne prend pas en charge les bases U Par conséquent, lorsque Dorado effectue un appel de base d'ARN, les fichiers de sortie résultants incluront T au lieu de U . Ceci est cohérent entre les types de fichiers de sortie.
| Modèles de référence | Compatible Modifications | Modifications Modèle Version | Données Échantillonnage Fréquence |
|---|---|---|---|
| [email protected] | 4 kHz | ||
| [email protected] | m5C m6A_DRACH inosine_m6A pseU | v1 v1 v1 v1 | 4 kHz |
| [email protected] | m5C m6A_DRACH inosine_m6A pseU | v1 v1 v1 v1 | 4 kHz |
| [email protected] | 4 kHz | ||
| [email protected] | m6A m6A_DRACH pseU | v1 v1 v1 | 4 kHz |
| [email protected] | m6A m6A_DRACH pseU | v1 v1 v1 | 4 kHz |
| [email protected] | 4 kHz | ||
| [email protected] | 4 kHz | ||
| [email protected] | m6A_DRACH | v1 | 4 kHz |
| rna002_70bps_fast@v3 | 3 kHz | ||
| rna002_70bps_hac@v3 | 3 kHz |
L'argument model dans Dorado peut spécifier soit un chemin de modèle, soit un complexe de modèle. Un modèle complexe doit commencer par le modèle simplex speed et suit cette syntaxe :
(fast|hac|sup)[@(version|latest)][,modification[@(version|latest)]][,...]
Les modèles de modification sélectionnés automatiquement correspondront toujours à la version du modèle simplex de base et seront la dernière version compatible, sauf si une version spécifique est définie par l'utilisateur. La sélection automatique du modèle de modification ne permettra pas le mélange de modèles de modification liés à différentes versions de modèles simplex.
Voici quelques exemples de complexes modèles :
| Complexe de modèles | Description |
|---|---|
| rapide | Dernier modèle rapide compatible |
| hac | Dernier modèle hac compatible |
| souper | Dernier modèle sup compatible |
| hac@dernier | Dernier modèle d'appel de base hac simplex compatible |
| [email protected] | Modèle hac d'appel de base simplex avec la version v4.2.0 |
| [email protected] | Modèle hac d'appel de base simplex avec la version v3.5.0 |
| hac,5mCG_5hmCG | Dernier modèle hac simplex compatible et dernier modèle de modifications 5mCG_5hmCG pour le modèle de base choisi |
| hac,5mCG_5hmCG@v2 | Dernier modèle hac simplex compatible et modèle de modifications 5mCG_5hmCG avec la version v2.0.0 |
| sup,5mCG_5hmCG,6mA | Dernier modèle sup compatible et derniers modèles de modifications compatibles 5mCG_5hmCG et 6mA |
Une fois que le processus de sélection automatique de modèles a trouvé le modèle approprié compte tenu des données d'entrée, il recherchera les répertoires de modèles existants pour éviter de télécharger inutilement des modèles. Le comportement de cette recherche peut être contrôlé comme suit :
Définition de l'argument CLI --models-directory - L'argument --models-directory peut être utilisé pour spécifier un répertoire dans lequel les modèles seront recherchés.
Définition de la variable d'environnement DORADO_MODELS_DIRECTORY - Ceci est identique à la définition de --models-directory mais a une priorité inférieure à celle de l'équivalent CLI.
Si ni --models-directory ni DORADO_MODELS_DIRECORY ne sont définis, le répertoire de travail actuel est recherché.
Si --models-directory ou DORADO_MODELS_DIRECTORY est défini automatiquement, les modèles téléchargés persisteront, sinon les modèles seront téléchargés dans un répertoire temporaire local et supprimés une fois Dorado terminé.
Dorado est équipé des bibliothèques nécessaires (telles que CUDA) pour son exécution. Cependant, sur certains systèmes d'exploitation, les bibliothèques système peuvent être choisies plutôt que celles de Dorado. Cet écart peut entraîner diverses erreurs, par exemple CuBLAS error 8 .
Pour résoudre ce problème, vous devez définir LD_LIBRARY_PATH pour qu'il pointe vers les bibliothèques de Dorado. Utilisez une commande comme celle-ci sous Linux (modifiez le chemin si nécessaire) :
$ export LD_LIBRARY_PATH=<PATH_TO_DORADO>/dorado-x.y.z-linux-x64/lib:$LD_LIBRARY_PATH
Sur macOS, l'exportation équivalente serait (changez le chemin selon le cas) :
$ export DYLD_LIBRARY_PATH=<PATH_TO_DORADO>/dorado-x.y.z-osx-arm64/lib:$DYLD_LIBRARY_PATH
L'appel de base duplex est un processus gourmand en E/S et peut mal fonctionner si vous utilisez un stockage en réseau ou un disque dur. Cela peut généralement être amélioré en fractionnant les fichiers POD5 de manière appropriée.
Installez d'abord les outils python POD5 :
La documentation du POD5 peut être trouvée ici.
$ pip install pod5
Exécutez ensuite pod5 view pour générer un tableau contenant des informations à diviser spécifiquement, les informations "canal".
$ pod5 view /path/to/your/dataset/ --include "read_id, channel" --output summary.tsv
Cela créera un fichier "summary.tsv" qui devrait ressembler à :
read_id channel 0000173c-bf67-44e7-9a9c-1ad0bc728e74 109 002fde30-9e23-4125-9eae-d112c18a81a7 463 ...
Exécutez maintenant pod5 subset pour copier les enregistrements de vos données sources vers les sorties par canal. Cela peut prendre un certain temps en fonction de la taille de votre ensemble de données
$ pod5 subset /path/to/your/dataset/ --summary summary.tsv --columns channel --output split_by_channel
La commande ci-dessus créera le répertoire de sortie split_by_channel et y écrira un fichier pod5 par canal unique. Les appels de base duplex pour ces lectures fractionnées seront désormais beaucoup plus rapides.
Si vous exécutez un appel de base duplex de manière distribuée (par exemple sur un cluster SLURM ou Kubernetes), il est important de diviser les fichiers POD5 comme décrit ci-dessus. La raison en est que l'appel de base duplex nécessite l'agrégation des lectures provenant d'une exécution de séquençage complète, qui seront réparties sur plusieurs fichiers POD5. La stratégie de fractionnement décrite ci-dessus garantit que toutes les lectures qui doivent être regroupées se trouvent dans le même fichier POD5. Une fois la division effectuée, vous pouvez exécuter plusieurs tâches sur des sous-ensembles plus petits du POD5 (par exemple, une tâche pour 100 canaux). Cela permettra aux appels de base d'être distribués entre les nœuds d'un cluster. Cela générera plusieurs BAM qui pourront être fusionnés. Cette approche offre également une certaine résilience, car si une tâche échoue, elle peut être redémarrée sans avoir à réexécuter le basecall sur l'ensemble de données.
Dorado fonctionne sur une large gamme de GPU mais il est principalement développé pour Nvidia A100/H100 et Apple Silicon. Dorado tente de trouver la taille de lot optimale pour les appels de base. Néanmoins, sur certains GPU à faible RAM, les utilisateurs peuvent être confrontés à des pannes de mémoire insuffisante.
Une solution potentielle à ce problème pourrait consister à définir manuellement une taille de lot à l'aide de la commande suivante :
dorado basecaller --batchsize 64 ...
Remarque : Réduire la consommation de mémoire en modifiant le paramètre chunksize n'est pas recommandé car cela influence les résultats de l'appel de base.
Une faible utilisation du GPU peut entraîner une réduction de la vitesse des appels de base. Ce problème peut être identifié à l'aide d'outils tels que nvidia-smi et nvtop . La faible utilisation du GPU provient souvent de goulots d’étranglement d’E/S lors des appels de base. Voici quelques mesures que vous pouvez prendre pour améliorer la situation :
Optez pour POD5 au lieu de .fast5 : POD5 offre des performances d'E/S supérieures et améliorera la vitesse de base dans les environnements contraints en E/S.
Transférer les données sur le disque local avant l'appel de base : un appel de base lent se produit souvent parce que les disques réseau ne peuvent pas fournir à Dorado une vitesse adéquate. Pour atténuer cela, assurez-vous que vos données sont aussi proches que possible de votre machine hôte.
Choisissez un SSD plutôt qu'un disque dur : en particulier pour les appels de base duplex, l'utilisation d'un SSD local peut offrir des avantages significatifs en termes de vitesse. Cela est dû au fait que l'algorithme d'appel de base duplex repose sur un accès aléatoire important aux données.
Lors de l'exécution dans PowerShell sous Windows, des précautions doivent être prises, car le codage par défaut pour la sortie de l'application est généralement UTF-16LE. Cela entraînera une corruption du fichier si la sortie standard est redirigée vers un fichier. Il est recommandé d'utiliser l'argument --output-dir pour émettre des fichiers BAM si PowerShell doit être utilisé. Par exemple, la commande suivante créera une sortie corrompue qui ne pourra pas être lue par samtools :
PS > dorado basecaller <args> > out.bam
Utilisez plutôt :
PS > dorado basecaller <args> --output-dir .
Pour les formats de sortie texte (SAM ou FASTQ), il est possible de remplacer l'encodage en sortie à l'aide de la commande out-file . Cette commande produira un fichier ascii SAM bien formé :
PS > dorado basecaller <args> --emit-sam | out-file -encoding Ascii out.sam
Notez que out-file avec encodage Ascii ne produiront pas de fichiers BAM bien formés.
En savoir plus sur le codage de sortie Powershell ici.
(c) 2024 Oxford Nanopore Technologies PLC.
Dorado est distribué selon les termes d'Oxford Nanopore Technologies PLC. Licence publique, version 1.0. Si une copie de la licence n'a pas été distribuée avec ce fichier, vous pouvez en obtenir une sur http://nanoporetech.com
