Contact
Un de nos experts vous contactera dans les plus brefs délais pour discuter de vos besoins et organiser une démo sur-mesure de la plateforme.
Cet article de blog présente le concept d'alignement de séquences, l'algorithme BLAST, et un exemple de son utilisation sur Qarnot.
L'Acide DésoxyriboNucléique, également connu sous le nom d'ADN, est l'information fondamentale de tout organisme vivant. Cette information est également définie comme le code génétique et sert d'orchestrateur pour les autres niveaux du système, des protéines aux cellules, aux tissus et aux organes. C'est pourquoi l'analyse des séquences d'ADN, d'ARN ou de protéines est devenue un défi clé en biologie, et un premier problème évident réside dans la comparaison d'énormes quantités de données de séquençage.
Un alignement de séquences est une méthode bio-informatique permettant de réarranger et de comparer deux séquences, le plus souvent du même type (ADN, ARN ou protéine). Dans les cas courants, nous avons deux ensembles de données en entrée, contenant chacun une ou plusieurs séquences. Le premier ensemble de données contient la requête (query), c'est-à-dire la ou les séquence(s) que nous devons analyser. Le second est appelé la référence ou la base de données, qui est l'ensemble des séquences comparées à la requête.
Le résultat final est globalement un fichier texte interprétable par l'humain, montrant les discordances (mismatches) ou les trous (gaps) entre la ou les requêtes et la ou les séquence(s) de référence. Un score est attribué à chaque résultat d'alignement, basé sur la similarité et la complexité des séquences.
L'alignement de séquences d'ADN permet d'interpréter les résultats comme des mutations ponctuelles, des insertions ou des délétions, telles que le Polymorphisme Mononucléotidique (SNP) ou la Variation Mononucléotidique (SNV). L'alignement est utilisé avec les données de Séquençage à Haut Débit (HTS), pour faire correspondre les séquences de requête à une séquence connue, ou de novo. De cette manière, l'alignement de séquences d'ARN peut également être utilisé pour quantifier l'expression des gènes. Enfin, l'alignement de séquences de protéines permet de visualiser les régions et motifs conservés, offrant un point de vue fonctionnel à partir des acides aminés les plus représentatifs. Une autre représentation de ce type d'alignement est un logo de séquence (voir exemple ci-dessous).
BLAST (Basic Local Alignment Search Tool) est initialement un outil web en ligne permettant de trouver des régions de similarité entre des séquences biologiques. Le programme compare des séquences de nucléotides ou d'acides aminés à des bases de données de séquences et calcule la signification statistique. Selon le type de données de séquençage, il existe différents outils spécifiques, mais dans cet article, nous nous concentrons sur l'utilisation de blastn (qui signifie l'alignement de séquences de nucléotides).
Dans cette partie, nous décrivons un exemple simple d'utilisation de BLAST, et plus particulièrement de l'outil blastn, sur Qarnot, en utilisant le SDK Python. Nous allons aligner une liste de séquences d'ADN de requête contre une autre liste de séquences d'ADN de référence.
Avant de commencer, vous devez créer un compte Qarnot, nous vous offrons 15 € de calcul sur votre abonnement.
Tout d'abord, dans un dossier Qarnot_blastn_example, créez un dossier nommé blastn_resources et enregistrez à l'intérieur les données suivantes qui contiennent deux séquences locales.
Téléchargez les ressources ici.
Maintenant, utilisons le SDK Python de Qarnot pour lancer le calcul distribué. Enregistrez le script suivant sous le nom run.py dans votre dossier Qarnot_blastn_example. Dans ce script, vous devez entrer votre Jeton Qarnot lié à votre compte pour utiliser notre plateforme.
#!/usr/bin/env python3
import sys
import qarnot
client_token = "<<<XXX put your token here XXX>>>"
docker_repo = "ncbi/blast"
docker_tag = "2.10.1"
def workflow():
task = conn.create_task('blastn-createdb', 'docker-batch', 1)
# Create the input bucket
input_bucket = conn.create_bucket('blastn-ref')
input_bucket.sync_directory("blastn_resources/dataset-blastn")
# Create the results bucket
output_bucket = conn.create_bucket('blastn-db')
# Create the task and attach the previous buckets
task.constants['DOCKER_REPO'] = docker_repo
task.constants['DOCKER_TAG'] = docker_tag
# Append the buckets tu the task
task.resources.append(input_bucket)
task.results = output_bucket
task.constants['DOCKER_CMD'] = "makeblastdb -in chr6.fna -dbtype nucl -parse_seqids -out chr6"
# Launch the task on qarnot before the sequencing, wait until it's finished
error_happened = False
try:
task.submit()
# Periodically polling the task, by retrieving the output
last_state = ''
done = False
while not done:
if task.state != last_state:
last_state = task.state
print("** {}".format(last_state))
done = task.wait(5)
sys.stdout.write(task.fresh_stdout())
sys.stderr.write(task.fresh_stderr())
# In case of failure, display the error(s)
if task.state == 'Failure':
print("** Errors: %s" % task.errors[0])
error_happened = True
finished_task = True
finally:
if error_happened:
return("An error happened")
else:
launch_blastn(output_bucket)
def launch_blastn(db_bucket):
task = conn.create_task('blastn-sequencing', 'docker-batch', 1)
# Create the input bucket
input_bucket = conn.create_bucket('blastn-ref')
# Create the results bucket
output_bucket = conn.create_bucket('blastn-align')
# Create the task and attach the previous buckets
task.constants['DOCKER_REPO'] = docker_repo
task.constants['DOCKER_TAG'] = docker_tag
# Append the buckets tu the task
task.resources = [ input_bucket, db_bucket ]
task.results = output_bucket
task.constants['DOCKER_CMD'] = "blastn -db chr6 -query hla-b.fsa -out results.out"
finished_task = False
error_happened = False
try:
task.submit()
# Periodically polling the task, by retrieving the output
last_state = ''
done = False
while not done:
if task.state != last_state:
last_state = task.state
print("** {}".format(last_state))
done = task.wait(5)
sys.stdout.write(task.fresh_stdout())
sys.stderr.write(task.fresh_stderr())
# In case of failure, display the error(s)
if task.state == 'Failure':
print("** Errors: %s" % task.errors[0])
error_happened = True
task.download_results("results")
finished_task = True
finally:
if error_happened:
return("An error happened")
else:
return("The sequence alignment finished successfully")
conn = qarnot.connection.Connection(client_token=client_token)
workflow()Dans le dossier Qarnot_blastn_example, suivez ces étapes pour configurer un environnement virtuel Python. Ensuite, vous pouvez exécuter le script Python depuis votre terminal en tapant chmod +x run.py puis ./run.py.
Pour résumer, le workflow fourni par ce projet permet de soumettre deux tâches consécutives :
La base de données est construite et transférée temporairement avec un bucket Qarnot, permettant de travailler en mode stateless (sans état).
Vous pouvez ensuite consulter les détails des tâches sur votre propre console ou sur la console Qarnot en cliquant sur votre tâche. Une fois terminée, les résultats de l'alignement (results.out) seront téléchargés sur votre ordinateur.
L'exercice ici est simple et vous permet de faire vos premiers pas dans la soumission d'un travail de bio-informatique simple sur Qarnot via le SDK Python. Vous pouvez également profiter de l'utilisation directe des tâches Qarnot pour gérer les dépendances entre les tâches au lieu du code Python présenté ici. N'hésitez pas à lire la documentation pour en savoir plus, ou à nous contacter pour obtenir des conseils ou un accompagnement pour vos besoins et projets.
