Créez des flux de travail de repliement des protéines pour accélérer la découverte de médicaments sur Amazon SageMaker

Créez des flux de travail de repliement des protéines sur Amazon SageMaker pour accélérer la découverte de médicaments.

Le développement de médicaments est un processus complexe et long qui implique le criblage de milliers de candidats médicamenteux et l’utilisation de méthodes computationnelles ou expérimentales pour évaluer les pistes. Selon McKinsey, un seul médicament peut prendre 10 ans et coûter en moyenne 2,6 milliards de dollars pour passer par l’identification de la cible de la maladie, le criblage des médicaments, la validation des cibles des médicaments et le lancement commercial final. La découverte de médicaments est le volet de recherche de ce processus qui génère des candidats médicaments ayant la plus grande probabilité d’être efficaces avec le moins de dommages pour les patients. Les méthodes d’apprentissage automatique (ML) peuvent aider à identifier des composés appropriés à chaque étape du processus de découverte de médicaments, ce qui permet une hiérarchisation et des tests de médicaments plus efficaces, permettant d’économiser des milliards de dollars en coûts de développement de médicaments (pour plus d’informations, consultez l’article AI in biopharma research: A time to focus and scale).

Les cibles des médicaments sont généralement des entités biologiques appelées protéines, les éléments constitutifs de la vie. La structure tridimensionnelle d’une protéine détermine la manière dont elle interagit avec un composé médicamenteux ; par conséquent, comprendre la structure tridimensionnelle des protéines peut apporter des améliorations significatives au processus de développement de médicaments en permettant de rechercher des composés médicamenteux qui s’adaptent mieux à la structure protéique cible. Un autre domaine où la prédiction de la structure des protéines peut être utile est la compréhension de la diversité des protéines, de sorte que nous ne sélectionnons que des médicaments qui ciblent sélectivement des protéines spécifiques sans affecter les autres protéines du corps (pour plus d’informations, consultez les recommandations GOT-IT pour l’amélioration de l’évaluation des cibles dans la recherche biomédicale). Les structures tridimensionnelles précises des protéines cibles permettent de concevoir des médicaments avec une plus grande spécificité et une plus faible probabilité d’interactions croisées avec d’autres protéines.

Cependant, prédire comment les protéines se replient dans leur structure tridimensionnelle est un problème difficile, et les méthodes expérimentales traditionnelles telles que la cristallographie aux rayons X et la spectroscopie RMN peuvent être longues et coûteuses. Les récents progrès dans les méthodes d’apprentissage profond pour la recherche sur les protéines ont montré des résultats prometteurs en utilisant des réseaux neuronaux pour prédire le repliement des protéines avec une précision remarquable. Des algorithmes de repliement tels que AlphaFold2, ESMFold, OpenFold et RoseTTAFold peuvent être utilisés pour construire rapidement des modèles précis de structures protéiques. Malheureusement, ces modèles sont coûteux en termes de calcul et les résultats peuvent être fastidieux à comparer à l’échelle de milliers de structures protéiques candidates. Une solution évolutive pour utiliser ces différents outils permettra aux chercheurs et aux équipes de R&D commerciales d’intégrer rapidement les dernières avancées en matière de prédiction de la structure des protéines, de gérer leurs processus d’expérimentation et de collaborer avec des partenaires de recherche.

Amazon SageMaker est un service entièrement géré permettant de préparer, construire, entraîner et déployer rapidement des modèles d’apprentissage automatique de haute qualité en réunissant un large éventail de capacités spécialement conçues pour l’apprentissage automatique. Il offre un environnement entièrement géré pour l’apprentissage automatique, en abstrayant les exigences d’infrastructure, de gestion des données et de mise à l’échelle, de sorte que vous puissiez vous concentrer sur la construction, la formation et les tests de vos modèles.

Dans cet article, nous présentons une solution d’apprentissage automatique entièrement gérée avec SageMaker qui simplifie l’exploitation des flux de travail de prédiction de la structure de repliement des protéines. Nous discutons d’abord de la solution dans les grandes lignes et de son expérience utilisateur. Ensuite, nous vous expliquons comment configurer facilement des flux de travail optimisés pour le calcul d’AlphaFold2 et OpenFold avec SageMaker. Enfin, nous vous montrons comment vous pouvez suivre et comparer les prédictions de structure des protéines dans le cadre d’une analyse typique. Le code de cette solution est disponible dans le référentiel GitHub suivant.

Aperçu de la solution

Dans cette solution, les scientifiques peuvent lancer des expériences de repliement des protéines de manière interactive, analyser la structure tridimensionnelle, suivre la progression des tâches et suivre les expériences dans Amazon SageMaker Studio.

La capture d’écran suivante montre une exécution unique d’un flux de travail de repliement des protéines avec Amazon SageMaker Studio. Elle comprend la visualisation de la structure tridimensionnelle dans un notebook, l’état d’exécution des tâches SageMaker dans le flux de travail et des liens vers les paramètres d’entrée et les données et journaux de sortie.

Le diagramme suivant illustre l’architecture de solution à haut niveau.

Pour comprendre l’architecture, nous définissons d’abord les principaux composants d’une expérience de repliement des protéines comme suit :

  • Fichier de séquence cible FASTA – Le format FASTA est un format textuel pour représenter des séquences nucléotidiques ou des séquences d’acides aminés (protéines), dans lequel les nucléotides ou les acides aminés sont représentés à l’aide de codes à une lettre.
  • Bases de données génétiques – Une base de données génétique est un ou plusieurs ensembles de données génétiques stockées avec un logiciel permettant aux utilisateurs de récupérer des données génétiques. Plusieurs bases de données génétiques sont nécessaires pour exécuter les algorithmes AlphaFold et OpenFold, tels que BFD, MGnify, PDB70, PDB, PDB seqres, UniRef30 (anciennement UniClust30), UniProt et UniRef90.
  • Alignement de séquences multiples (MSA) – Un alignement de séquences est une manière d’organiser les séquences primaires d’une protéine pour identifier les régions de similitude qui peuvent être une conséquence de relations fonctionnelles, structurales ou évolutives entre les séquences. Les données de MSA sont incluses dans les fonctionnalités d’entrée pour les prédictions.
  • Prédiction de la structure des protéines – La structure des séquences cibles d’entrée est prédite à l’aide d’algorithmes de repliement tels que AlphaFold2 et OpenFold qui utilisent une architecture de transformateur multi-piste formée sur des modèles de protéines connus.
  • Visualisation et mesures – Visualisez la structure tridimensionnelle avec la bibliothèque py3Dmol comme une visualisation interactive en 3D. Vous pouvez utiliser des mesures pour évaluer et comparer les prédictions de structure, notamment la déviation quadratique moyenne (RMSD) et le score de modélisation du modèle (TM-score).

Le flux de travail contient les étapes suivantes :

  1. Les scientifiques utilisent l’IDE SageMaker ML basé sur le Web pour explorer la base de code, construire des flux de travail d’analyse de séquences de protéines dans les notebooks SageMaker Studio et exécuter des pipelines de repliement des protéines via l’interface utilisateur graphique dans SageMaker Studio ou le SDK SageMaker.
  2. Les bases de données génétiques et structurales requises par AlphaFold et OpenFold sont téléchargées avant la configuration du pipeline à l’aide de Amazon SageMaker Processing, une fonction de calcul éphémère pour le traitement des données ML, vers un compartiment Amazon Simple Storage Service (Amazon S3). Avec SageMaker Processing, vous pouvez exécuter un travail de longue durée avec un calcul approprié sans configurer de grappe de calcul et de stockage et sans avoir besoin de fermer la grappe. Les données sont automatiquement enregistrées dans un emplacement spécifié du compartiment S3.
  3. Un système de fichiers Amazon FSx for Lustre est configuré, le référentiel de données étant l’emplacement du compartiment S3 où les bases de données sont enregistrées. FSx for Lustre peut être mis à l’échelle jusqu’à des centaines de Go/s de débit et des millions d’IOPS avec une récupération de fichiers à faible latence. Lorsqu’un travail d’estimation est lancé, SageMaker monte le système de fichiers FSx for Lustre sur le système de fichiers de l’instance, puis lance le script.
  4. Amazon SageMaker Pipelines est utilisé pour orchestrer plusieurs exécutions d’algorithmes de repliement des protéines. SageMaker Pipelines offre une interface visuelle souhaitée pour la soumission interactive des travaux, la traçabilité de la progression et la reproductibilité.
  5. Dans un pipeline, deux algorithmes de repliement des protéines intensifs en calcul – AlphaFold et OpenFold – sont exécutés avec des estimateurs SageMaker. Cette configuration prend en charge le montage d’un système de fichiers FSx for Lustre pour une recherche de base de données à haut débit dans les algorithmes. Une seule exécution d’inférence est divisée en deux étapes : une étape de construction MSA utilisant une instance CPU optimale et une étape de prédiction de structure utilisant une instance GPU. Ces sous-étapes, comme SageMaker Processing à l’étape 2, sont éphémères, à la demande et entièrement gérées. Les fichiers de sortie du travail tels que les fichiers MSA, les fichiers de structure pdb prédits et d’autres fichiers de métadonnées sont enregistrés dans un emplacement S3 spécifié. Un pipeline peut être conçu pour exécuter un seul algorithme de repliement des protéines ou exécuter à la fois AlphaFold et OpenFold après une construction MSA commune.
  6. Les exécutions de la prédiction de repliement des protéines sont automatiquement suivies par Amazon SageMaker Experiments pour une analyse et une comparaison ultérieures. Les journaux de travail sont conservés dans Amazon CloudWatch pour la surveillance.

Prérequis

Pour suivre cet article et exécuter cette solution, vous devez avoir accompli plusieurs prérequis. Consultez le dépôt GitHub pour une explication détaillée de chaque étape.

  • Un domaine SageMaker et un profil d’utilisateur – Si vous n’avez pas de domaine SageMaker Studio, consultez la procédure de mise en route du domaine Amazon SageMaker à l’aide de la configuration rapide.
  • Politiques IAM – Votre utilisateur doit avoir la politique IAM AmazonSageMakerFullAccess d’AWS Identity and Access Management (IAM) attachée, la possibilité de créer des images de conteneur Docker dans Amazon Elastic Container Registry (Amazon ECR) et des systèmes de fichiers FSx for Lustre créés. Consultez le fichier readme pour plus de détails.
  • Réseau – Un VPC avec un point de terminaison VPC Amazon S3. Nous utilisons cet emplacement VPC pour provisionner le système de fichiers FSx for Lustre et les travaux SageMaker.
  • Ressources Docker – Exécutez le fichier 00-prerequisite.ipynb du dépôt pour créer les images Docker, télécharger la base de données génétique vers Amazon S3 et créer un système de fichiers FSx for Lustre avec une association de référentiel de données vers le compartiment S3.

Exécution du repliement des protéines sur SageMaker

Nous utilisons les capacités entièrement gérées de SageMaker pour exécuter des travaux de repliement des protéines intensifs en calcul sans trop de frais généraux d’infrastructure. SageMaker utilise des images de conteneur pour exécuter des scripts personnalisés pour le traitement générique des données, la formation et l’hébergement. Vous pouvez facilement démarrer un travail éphémère à la demande qui exécute un programme avec une image de conteneur avec quelques lignes du SDK SageMaker sans gérer vous-même l’infrastructure de calcul. Plus précisément, le travail de l’estimateur SageMaker offre une flexibilité en ce qui concerne le choix de l’image de conteneur, du script d’exécution et de la configuration de l’instance, et prend en charge une grande variété d’options de stockage, y compris des systèmes de fichiers tels que FSx for Lustre. Le diagramme suivant illustre cette architecture.

Des algorithmes de repliement tels que AlphaFold et OpenFold utilisent une architecture de transformateur multivoie formée sur des modèles de protéines connus pour prédire la structure de séquences de peptides inconnues. Ces prédictions peuvent être exécutées sur des instances GPU pour fournir le meilleur débit et la latence la plus faible. Cependant, les caractéristiques d’entrée de ces prédictions incluent des données MSA. Les algorithmes MSA dépendent du CPU et peuvent nécessiter plusieurs heures de temps de traitement.

L’exécution des étapes de prédiction de MSA et de structure dans le même environnement informatique peut être inefficace en termes de coûts car les ressources GPU coûteuses restent inactives pendant l’exécution de l’étape de MSA. Par conséquent, nous optimisons le flux de travail en deux étapes. Tout d’abord, nous exécutons un travail d’estimateur SageMaker sur une instance CPU spécifiquement pour calculer l’alignement MSA à partir d’une séquence FASTA d’entrée particulière et de bases de données génétiques sources. Ensuite, nous exécutons un travail d’estimateur SageMaker sur une instance GPU pour prédire la structure de la protéine avec un alignement MSA d’entrée donné et un algorithme de repliement tel que AlphaFold ou OpenFold.

Exécuter la génération de MSA

Pour le calcul de MSA, nous incluons un script personnalisé run_create_alignment.sh et le script create_alignments.py qui est adopté à partir du code source existant de prédiction AlphaFold run_alphafold.py. Notez que ce script peut nécessiter une mise à jour si le code source AlphaFold est mis à jour. Le script personnalisé est fourni à l’estimateur SageMaker via le mode script. Les principaux composants de l’image du conteneur, de l’implémentation du mode script et de la configuration d’un travail d’estimateur SageMaker font également partie de l’étape suivante d’exécution des algorithmes de repliement, et sont décrits plus en détail dans la section suivante.

Exécuter AlphaFold

Nous commençons par exécuter une prédiction de structure AlphaFold avec une seule séquence de protéine en utilisant SageMaker. L’exécution d’une tâche AlphaFold implique trois étapes simples, comme on peut le voir dans 01-run_stepbystep.ipynb. Tout d’abord, nous construisons une image de conteneur Docker basée sur le Dockerfile d’AlphaFold afin de pouvoir également exécuter AlphaFold dans SageMaker. Ensuite, nous construisons le script run_alphafold.sh qui indique comment AlphaFold doit être exécuté. Enfin, nous construisons et exécutons un estimateur SageMaker avec le script, le conteneur, le type d’instance, les données et la configuration pour la tâche.

Image du conteneur

L’exigence d’exécution d’une image de conteneur pour exécuter AlphaFold (OpenFold également) dans SageMaker peut être grandement simplifiée avec le Dockerfile d’AlphaFold. Nous n’avons besoin d’ajouter que quelques couches simples par-dessus pour installer une bibliothèque Python spécifique à SageMaker afin qu’un travail SageMaker puisse communiquer avec l’image du conteneur. Voir le code suivant :

# Dans Dockerfile.alphafold
## Spécifique à SageMaker
RUN pip3 install sagemaker-training --upgrade --no-cache-dir
ENV PATH="/opt/ml/code:${PATH}"
# cette variable d'environnement est utilisée par l'estimateur SageMaker pour déterminer notre répertoire de code utilisateur
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code

Script d’entrée

Nous fournissons ensuite le script run_alphafold.sh qui exécute run_alphafold.py à partir du référentiel AlphaFold actuellement placé dans le conteneur /app/alphafold/run_alphafold.py. Lorsque ce script est exécuté, l’emplacement des bases de données génétiques et de la séquence FASTA d’entrée sera renseigné par SageMaker en tant que variables d’environnement (SM_CHANNEL_GENETIC et SM_CHANNEL_FASTA, respectivement). Pour plus d’informations, consultez la configuration des données d’entrée.

Tâche d’estimateur

Nous créons ensuite une tâche en utilisant un estimateur SageMaker avec les arguments d’entrée clés suivants, qui indiquent à SageMaker d’exécuter un script spécifique à l’aide d’un conteneur spécifié avec le type ou le nombre d’instances, votre option de réseau préférée et d’autres paramètres pour la tâche. vpc_subnet_ids et security_group_ids indiquent à la tâche de s’exécuter à l’intérieur d’un VPC spécifique où le système de fichiers FSx for Lustre est installé afin que nous puissions monter et accéder au système de fichiers dans la tâche SageMaker. Le chemin de sortie fait référence à un emplacement du bucket S3 où le produit final d’AlphaFold sera téléchargé à la fin d’une tâche réussie par SageMaker automatiquement. Ici, nous définissons également un paramètre DB_PRESET, par exemple, à passer et à accéder dans run_alphafold.sh en tant que variable d’environnement pendant l’exécution. Voir le code suivant :

from sagemaker.estimator import Estimator
alphafold_image_uri=f'{account}.dkr.ecr.{region}.amazonaws.com/sagemaker-studio-alphafold:v2.3.0'
instance_type='ml.g5.2xlarge'
instance_count=1
vpc_subnet_ids=['subnet-xxxxxxxxx'] # il est possible d'utiliser un VPC par défaut
security_group_ids=['sg-xxxxxxxxx']
env={'DB_PRESET': db_preset} # <full_dbs|reduced_dbs>
output_path='s3://%s/%s/job-output/'%(default_bucket, prefix)

estimator_alphafold = Estimator(
source_dir='src', # répertoire où se trouvent run_alphafold.sh et d'autres fichiers d'exécution
entry_point='run_alphafold.sh', # notre script qui exécute /app/alphafold/run_alphafold.py
image_uri=alphafold_image_uri, # image du conteneur à utiliser
instance_count=instance_count, #
instance_type=instance_type,
subnets=vpc_subnet_ids,
security_group_ids=security_group_ids,
environment=env,
output_path=output_path,
...)

Enfin, nous rassemblons les données et nous indiquons au travail où elles se trouvent. Le canal de données fasta est défini comme une entrée de données S3 qui sera téléchargée depuis un emplacement S3 vers l’instance de calcul au début du travail. Cela permet une grande flexibilité pour gérer et spécifier la séquence d’entrée. D’autre part, le canal de données genetic est défini comme une entrée FileSystemInput qui sera montée sur l’instance au début du travail. L’utilisation d’un système de fichiers FSx pour Lustre pour importer près de 3 To de données évite de télécharger plusieurs fois les données depuis un compartiment S3 vers une instance de calcul. Nous appelons la méthode .fit pour lancer un travail AlphaFold :

from sagemaker.inputs import FileSystemInput
file_system_id='fs-xxxxxxxxx'
fsx_mount_id='xxxxxxxx'
file_system_directory_path=f'/{fsx_mount_id}/{prefix}/alphafold-genetic-db' # doit être le préfixe complet du référentiel de données S3

file_system_access_mode='ro' # Spécifiez le mode d'accès (lecture seule)
file_system_type='FSxLustre' # Spécifiez votre type de système de fichiers

genetic_db = FileSystemInput(
file_system_id=file_system_id,
file_system_type=file_system_type,
directory_path=file_system_directory_path,
file_system_access_mode=file_system_access_mode)

s3_fasta=sess.upload_data(path='sequence_input/T1030.fasta', # Emplacement FASTA localement
key_prefix='alphafoldv2/sequence_input') # Préfixe S3. Le compartiment est le compartiment par défaut de SageMaker
fasta = sagemaker.inputs.TrainingInput(s3_fasta,
distribution='FullyReplicated',
s3_data_type='S3Prefix',
input_mode='File')
data_channels_alphafold = {'genetic': genetic_db, 'fasta': fasta}

estimator_alphafold.fit(inputs=data_channels_alphafold,
wait=False) # wait=False renvoie la cellule dans le notebook ; mettez à True pour voir les journaux au fur et à mesure de l'avancement du travail

C’est tout. Nous venons de soumettre un travail à SageMaker pour exécuter AlphaFold. Les journaux et les sorties, y compris les fichiers de prédiction .pdb, seront écrits dans Amazon S3.

Exécuter OpenFold

L’exécution de OpenFold dans SageMaker suit un schéma similaire, comme le montre la deuxième moitié de 01-run_stepbystep.ipynb. Nous ajoutons d’abord une couche simple pour obtenir la bibliothèque spécifique à SageMaker afin de rendre l’image du conteneur compatible avec SageMaker en plus du fichier Docker de OpenFold. Ensuite, nous construisons un fichier run_openfold.sh comme point d’entrée pour le travail SageMaker. Dans run_openfold.sh, nous exécutons run_pretrained_openfold.py de OpenFold, qui est disponible dans l’image du conteneur avec les mêmes bases de données génétiques que nous avons téléchargées pour AlphaFold et les poids du modèle de OpenFold (--openfold_checkpoint_path). En ce qui concerne les emplacements des données d’entrée, en plus du canal des bases de données génétiques et du canal FASTA, nous introduisons un troisième canal, SM_CHANNEL_PARAM, afin de pouvoir passer de manière flexible les poids du modèle de choix depuis la construction de l’estimateur lorsque nous définissons et soumettons un travail. Avec l’estimateur SageMaker, nous pouvons facilement soumettre des travaux avec différentes entry_point, image_uri, environment, inputs et autres configurations pour OpenFold avec la même signature. Pour le canal de données, nous ajoutons un nouveau canal, param, en tant qu’entrée Amazon S3 avec l’utilisation des mêmes bases de données génétiques du système de fichiers FSx pour Lustre et du fichier FASTA d’Amazon S3. Cela nous permet une fois de plus de spécifier facilement le poids du modèle à utiliser depuis la construction du travail. Voyez le code suivant :

s3_param=sess.upload_data(path='openfold_params/finetuning_ptm_2.pt',
key_prefix=f'{prefix}/openfold_params')
param = sagemaker.inputs.TrainingInput(s3_param,
distribution="FullyReplicated",
s3_data_type="S3Prefix",
input_mode='File')

data_channels_openfold = {"genetic": genetic_db, 'fasta': fasta, 'param': param}

estimator_openfold.fit(inputs=data_channels_openfold,
wait=False)

Pour accéder à la sortie finale une fois que le travail est terminé, exécutez les commandes suivantes :

!aws s3 cp {estimator_openfold.model_data} openfold_output/model.tar.gz
!tar zxfv openfold_output/model.tar.gz -C openfold_output/

Performance d’exécution

Le tableau suivant montre les économies de coûts de 57% et 51% pour AlphaFold et OpenFold, respectivement, en divisant l’alignement MSA et les algorithmes de pliage en deux tâches par rapport à une seule tâche de calcul. Cela nous permet de dimensionner correctement le calcul pour chaque tâche : ml.m5.4xlarge pour l’alignement MSA et ml.g5.2xlarge pour AlphaFold et OpenFold.

Détails de la tâche Type d’instance Séquence FASTA d’entrée Temps d’exécution Coût
Alignement MSA + OpenFold ml.g5.4xlarge T1030 50 minutes 1,69 $
Alignement MSA + AlphaFold ml.g5.4xlarge T1030 65 minutes 2,19 $
Alignement MSA ml.m5.4xlarge T1030 46 minutes 0,71 $
OpenFold ml.g5.2xlarge T1030 6 minutes 0,15 $
AlphaFold ml.g5.2xlarge T1030 21 minutes 0,53 $

Créez un flux de travail répétable en utilisant SageMaker Pipelines

Avec SageMaker Pipelines, nous pouvons créer un flux de travail d’apprentissage automatique qui se charge de gérer les données entre les étapes, d’orchestrer leurs exécutions et de les journaliser. SageMaker Pipelines nous offre également une interface utilisateur pour visualiser notre pipeline et exécuter facilement notre flux de travail d’apprentissage automatique.

Un pipeline est créé en combinant un certain nombre d’étapes. Dans ce pipeline, nous combinons trois étapes de formation, qui nécessitent un estimateur SageMaker. Les estimateurs définis dans ce notebook sont très similaires à ceux définis dans 01-run_stepbystep.ipynb, à l’exception que nous utilisons des emplacements Amazon S3 pour pointer vers nos entrées et sorties. Les variables dynamiques permettent à SageMaker Pipelines d’exécuter les étapes les unes après les autres et permettent également à l’utilisateur de réessayer les étapes échouées. La capture d’écran suivante montre un graphe acyclique dirigé (DAG), qui fournit des informations sur les exigences et les relations entre chaque étape de notre pipeline.

Variables dynamiques

SageMaker Pipelines est capable de prendre des entrées utilisateur au début de chaque exécution de pipeline. Nous définissons les variables dynamiques suivantes, que nous souhaitons modifier lors de chaque expérience :

  • FastaInputS3URI – URI Amazon S3 du fichier FASTA téléchargé via SDK, Boto3 ou manuellement.
  • FastFileName – Nom du fichier FASTA.
  • db_preset – Sélection entre full_dbs ou reduced_dbs.
  • MaxTemplateDate – L’étape MSA d’AlphaFold recherchera les modèles disponibles avant la date spécifiée par ce paramètre.
  • ModelPreset – Sélectionnez parmi les modèles AlphaFold, y compris monomer, monomer_casp14, monomer_ptm et multimer.
  • NumMultimerPredictionsPerModel – Nombre de semences à exécuter par modèle lors de l’utilisation du système multimer.
  • InferenceInstanceType – Type d’instance à utiliser pour les étapes d’inférence (à la fois AlphaFold et OpenFold). La valeur par défaut est ml.g5.2xlarge.
  • MSAInstanceType – Type d’instance à utiliser pour l’étape MSA. La valeur par défaut est ml.m5.4xlarge.

Voir le code suivant:

fasta_file = ParameterString(name="FastaFileName")
fasta_input = ParameterString(name="FastaInputS3URI")
pipeline_db_preset = ParameterString(name="db_preset",
default_value='full_dbs',
enum_values=['full_dbs', 'reduced_dbs'])
max_template_date = ParameterString(name="MaxTemplateDate")
model_preset = ParameterString(name="ModelPreset")
num_multimer_predictions_per_model = ParameterString(name="NumMultimerPredictionsPerModel")
msa_instance_type = ParameterString(name="MSAInstanceType", default_value='ml.m5.4xlarge')
instance_type = ParameterString(name="InferenceInstanceType", default_value='ml.g5.2xlarge')

Un pipeline SageMaker est construit en définissant une série d’étapes puis en les enchaînant dans un ordre spécifique où la sortie d’une étape précédente devient l’entrée de l’étape suivante. Les étapes peuvent être exécutées en parallèle et définies pour dépendre d’une étape précédente. Dans ce pipeline, nous définissons une étape MSA, qui est la dépendance pour une étape d’inférence AlphaFold et une étape d’inférence OpenFold qui s’exécutent en parallèle. Voir le code suivant:

step_msa = TrainingStep(
name="RunMSA",
step_args=pipeline_msa_args,
)

step_alphafold = TrainingStep(
name="RunAlphaFold",
step_args=pipeline_alphafold_default_args,
)
step_alphafold.add_depends_on([step_msa])

step_openfold = TrainingStep(
name="RunOpenFold",
step_args=pipeline_openfold_args,
)
step_openfold.add_depends_on([step_msa]

Pour assembler toutes les étapes, nous appelons la classe Pipeline et fournissons un nom de pipeline, des variables d’entrée de pipeline et les étapes individuelles:

pipeline_name = f"ProteinFoldWorkflow"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
fasta_input,
instance_type,
msa_instance_type,
pipeline_db_preset
],
steps=[step_msa, step_alphafold, step_openfold],
)

pipeline.upsert(role_arn=role, # exécutez ceci s'il s'agit de la première configuration du pipeline
description='Protein_Workflow_MSA')

Exécuter le pipeline

Dans la dernière cellule du notebook 02-define_pipeline.ipynb, nous montrons comment exécuter un pipeline en utilisant le SDK SageMaker. Les variables dynamiques que nous avons décrites précédemment sont fournies comme suit:

!mkdir ./sequence_input/
!curl 'https://www.predictioncenter.org/casp14/target.cgi?target=T1030&view=sequence' > ./sequence_input/T1030.fasta
fasta_file_name = 'T1030.fasta'

pathName = f'./sequence_input/{fasta_file_name}'
s3_fasta=sess.upload_data(path=pathName,
key_prefix='alphafoldv2/sequence_input')

PipelineParameters={
'FastaInputS3URI':s3_fasta,
'db_preset': 'full_dbs',
'FastaFileName': fasta_file_name,
'MaxTemplateDate': '2020-05-14',
'ModelPreset': 'monomer',
'NumMultimerPredictionsPerModel': '5',
'InferenceInstanceType':'ml.g5.2xlarge',
'MSAInstanceType':'ml.m5.4xlarge'
}
execution = pipeline.start(execution_display_name='SDK-Executetd',
execution_description='This pipeline was executed via SageMaker SDK',
parameters=PipelineParameters
)

Suivre les expériences et comparer les structures de protéines

Pour notre expérience, nous utilisons une séquence protéique d’exemple de la compétition CASP14, qui fournit un mécanisme indépendant pour l’évaluation des méthodes de modélisation de la structure des protéines. La cible T1030 est dérivée de la protéine PDB 6P00 et compte 237 acides aminés dans la séquence principale. Nous exécutons le pipeline SageMaker pour prédire la structure de protéine de cette séquence d’entrée avec les algorithmes OpenFold et AlphaFold.

Lorsque le pipeline est terminé, nous téléchargeons les fichiers .pdb prédits à partir de chaque travail de pliage et visualisons la structure dans le notebook en utilisant py3Dmol, comme dans le notebook 04-compare_alphafold_openfold.ipynb.

La capture d’écran suivante montre la prédiction du travail de prédiction AlphaFold.

La structure prédite est comparée à sa structure de référence de base connue avec le code PDB 6poo archivé dans RCSB. Nous analysons les performances de la prédiction par rapport au code PDB de base 6poo avec trois métriques : RMSD, RMSD avec superposition et score de modélisation de modèle, comme décrit dans la section Comparaison de structures.

. Séquence d’entrée Comparaison avec RMSD RMSD avec superposition Score de modélisation de modèle
AlphaFold T1030 6poo 247.26 3.87 0.3515

Les algorithmes de pliage sont maintenant comparés les uns aux autres pour plusieurs séquences FASTA : T1030, T1090 et T1076. Les nouvelles séquences cibles peuvent ne pas avoir la structure de pdb de base dans les bases de données de référence et il est donc utile de comparer la variabilité entre les algorithmes de pliage.

. Séquence d’entrée Comparaison avec RMSD RMSD avec superposition Score de modélisation de modèle
AlphaFold T1030 OpenFold 73.21 24.8 0.0018
AlphaFold T1076 OpenFold 38.71 28.87 0.0047
AlphaFold T1090 OpenFold 30.03 20.45 0.005

La capture d’écran suivante montre les exécutions de ProteinFoldWorkflow pour les trois séquences d’entrée FASTA avec SageMaker Pipeline :

Nous enregistrons également les métriques avec SageMaker Experiments en tant que nouvelles exécutions de la même expérience créée par le pipeline :

from sagemaker.experiments.run import Run, load_run
metric_type='compare:'
experiment_name = 'proteinfoldworkflow'
with Run(experiment_name=experiment_name, run_name=input_name_1, sagemaker_session=sess) as run:
run.log_metric(name=metric_type + "rmsd_cur", value=rmsd_cur_one, step=1)
run.log_metric(name=metric_type + "rmds_fit", value=rmsd_fit_one, step=1)
run.log_metric(name=metric_type + "tm_score", value=tmscore_one, step=1)

Nous analysons ensuite et visualisons ces exécutions sur la page Experiments dans SageMaker Studio.

Le graphique suivant représente la valeur RMSD entre AlphaFold et OpenFold pour les trois séquences : T1030, T1076 et T1090.

Conclusion

Dans cet article, nous avons décrit comment vous pouvez utiliser SageMaker Pipelines pour configurer et exécuter des flux de travail de repliement des protéines avec deux algorithmes populaires de prédiction de structure : AlphaFold2 et OpenFold. Nous avons présenté une architecture de solution performante en termes de coûts avec plusieurs tâches qui sépare les exigences de calcul pour la génération de MSA de la prédiction de structure. Nous avons également mis en évidence comment vous pouvez visualiser, évaluer et comparer les structures tridimensionnelles prédites des protéines dans SageMaker Studio.

Pour commencer avec les flux de travail de repliement des protéines sur SageMaker, consultez le code d’exemple dans le dépôt GitHub.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Related articles

Discover more

Want to read more? Go here