AlphaPulldown maintient entièrement la compatibilité descendante avec les fichiers d'entrée et les scripts des versions 1.x.
AlphaPulldown : version 2.0.0 (bêta)
Table des matières
À propos d'AlphaPulldown
Aperçu
Bases de données Alphafold
Snakemake AlphaPulldown
1.Installation
2.Configuration
3. Exécution
Exécutez l’interface de ligne de commande Python AlphaPulldown
Créer un bloc-notes Jupyter
Créer un tableau de résultats
Étape suivante
Étape suivante
2.1. Exécution de base
2.2. Exemple exécuté avec SLURM (cluster EMBL)
2.3. Mode déroulant
2.4. Mode Tous contre Tous
2.5. Exécuter avec des modèles personnalisés (TrueMultimer)
2.6. Exécuter avec des données de réticulation (AlphaLink2)
Saisir
Exécution de script : prédiction de structure
Sortir
Étape suivante
Saisir
Exécution de scripts
Résultat et étape suivante
Mode « pulldown » à entrées multiples
Résultat et étape suivante
Saisir
Exécution de script pour la prédiction de structure TrueMultimer
Résultat et étape suivante
Saisir
Exécuter avec la prédiction AlphaLink2 via AlphaPulldown
Résultat et étape suivante
1.1. Exécution de base
1.2. Exemples de scripts bash pour SLURM (cluster EMBL)
1.3. Exécuter à l'aide des bases de données MMseqs2 et ColabFold (plus rapide)
1.4. Exécuter avec des modèles personnalisés (TrueMultimer)
Saisir
Exécution de scripts
Sortir
Étape suivante
Saisir
Exécution de scripts
Étape suivante
Exécuter MMseqs2 à distance
Sortir
Exécuter MMseqs2 localement
Étape suivante
Saisir
Exécution de scripts
Sortir
Étape suivante
0,1. Créer un environnement Anaconda
0,2. Installation à l'aide de pip
0,3. Installation des outils d'analyse Aval
0,4. Installation pour les données d'entrée de liaison croisée par AlphaLink2 (facultatif !)
0,5. Installation pour les développeurs
0.Installation
1. Calculer l'alignement de séquences multiples (MSA) et les fonctionnalités de modèle (étage CPU)
2. Prédire les structures (étape GPU)
3. Analyse et visualisation
Analyse en aval
Diminuer la taille de la sortie AlphaPulldown
Convertir des modèles du format PDB au format ModelCIF
1. Convertissez tous les modèles en fichiers ModelCIF séparés
2. Convertissez uniquement un modèle unique spécifique pour chaque complexe
3. Avoir un modèle représentatif et conserver les modèles associés
Archives Zip associées
Options diverses
Carnet Jupyter
Tableau des résultats
Scripts de gestion des résultats
Base de données des fonctionnalités
Liste des organismes disponibles :
Téléchargez les fonctionnalités spécifiques aux protéines :
Téléchargez toutes les fonctionnalités d'un organisme :
Mesures:
Vérifiez l'installation :
Installation
Configuration
Fonctionnalités de téléchargement
AlphaPulldown est une implémentation personnalisée d'AlphaFold-Multimer conçue pour le criblage personnalisable à haut débit des interactions protéine-protéine. Il étend les capacités d'AlphaFold en incorporant des options d'exécution supplémentaires, telles que des modèles structurels multimériques personnalisables (TrueMultimer), l'alignement de séquences multiples (MSA) MMseqs2 via les bases de données ColabFold, les prédictions de fragments de protéines et la possibilité d'incorporer des données de spécifications de masse comme entrée à l'aide d'AlphaLink2.
AlphaPulldown peut être utilisé de deux manières : soit par un pipeline en deux étapes constitué de scripts python , soit par un pipeline Snakemake dans son ensemble. Pour plus de détails sur l'utilisation du pipeline Snakemake, veuillez vous référer au référentiel GitHub séparé.
Figure 1 Présentation du flux de travail AlphaPulldown
Le workflow AlphaPulldown comprend les 3 étapes suivantes :
Créez et stockez les fonctionnalités MSA et modèles :
Au cours de cette étape, AlphaFold recherche dans les bases de données préinstallées à l'aide de HMMER pour chaque séquence protéique interrogée et calcule plusieurs alignements de séquences (MSA) pour tous les homologues trouvés. Il recherche également des structures homologues à utiliser comme modèles pour la génération de fonctionnalités. Cette étape nécessite uniquement du CPU.
Les options personnalisables incluent :
Pour accélérer le processus de recherche, MMSeq2 peut être utilisé à la place du HHMER par défaut.
Utilisez MSA personnalisé.
Utilisez un modèle structurel personnalisé, notamment multimérique (mode TrueMultimer).
Prédiction de structure :
Au cours de cette étape, le réseau neuronal AlphaFold exécute et produit la structure protéique finale, nécessitant un GPU. L’un des principaux atouts d’AlphaPulldown réside dans sa capacité à définir de manière flexible la manière dont les protéines sont combinées pour la prédiction de la structure des complexes protéiques. Voici les trois principales approches que vous pouvez utiliser :
Figure 2 Trois scénarios typiques couverts par AlphaPulldown
De plus, AlphaPulldown permet également :
Sélectionnez uniquement la ou les régions de protéines que vous souhaitez prédire au lieu des séquences complètes.
Ajustez la profondeur du MSA pour contrôler l’influence du MSA initial sur le modèle final.
Intégrez les données de réticulation à haut débit avec la modélisation AlphaFold via AlphaLink2.
Fichier unique (mode personnalisé ou mode homo-oligomère) : créez un fichier dans lequel chaque ligne répertorie les séquences protéiques que vous souhaitez prédire ensemble ou chaque ligne indique au programme de modéliser les homo-oligomères avec le nombre de copies spécifié.
Fichiers multiples (mode déroulant) : fournissez plusieurs fichiers, chacun contenant des séquences de protéines. AlphaPulldown générera automatiquement toutes les combinaisons possibles en associant des lignes de noms de protéines de chaque fichier.
All versus all : AlphaPulldown générera toutes les combinaisons possibles non redondantes de protéines dans la liste.
Analyse aval des résultats :
Les résultats de tous les modèles prédits peuvent être systématisés en utilisant l'une des options suivantes :
Un tableau contenant divers scores et paramètres physiques des interactions complexes protéiques.
Un notebook Jupyter avec des modèles de protéines 3D interactifs et des tracés PAE.
Pour le calcul standard du MSA et des caractéristiques, AlphaPulldown nécessite des bases de données génétiques. Vérifiez si vous avez téléchargé les paramètres et bases de données nécessaires (par exemple, BFD, MGnify, etc.) comme indiqué dans la documentation d'AlphaFold. Vous devriez avoir un répertoire structuré comme suit :
alphafold_database/ # Total: ~ 2.2 TB (download: 438 GB)
bfd/ # ~ 1.7 TB (download: 271.6 GB)
# 6 files.
mgnify/ # ~ 64 GB (download: 32.9 GB)
mgy_clusters_2018_12.fa
params/ # ~ 3.5 GB (download: 3.5 GB)
# 5 CASP14 models,
# 5 pTM models,
# 5 AlphaFold-Multimer models,
# LICENSE,
# = 16 files.
pdb70/ # ~ 56 GB (download: 19.5 GB)
# 9 files.
pdb_mmcif/ # ~ 206 GB (download: 46 GB)
mmcif_files/
# About 227,000 .cif files.
obsolete.dat
pdb_seqres/ # ~ 0.2 GB (download: 0.2 GB)
pdb_seqres.txt
small_bfd/ # ~ 17 GB (download: 9.6 GB)
bfd-first_non_consensus_sequences.fasta
uniref30/ # ~ 86 GB (download: 24.9 GB)
# 14 files.
uniprot/ # ~ 98.3 GB (download: 49 GB)
uniprot.fasta
uniref90/ # ~ 58 GB (download: 29.7 GB)
uniref90.fastaNote
Uniclust30 est la version de la base de données générée avant 2019, UniRef30 est celle générée après 2019. Veuillez noter qu'AlphaPulldown utilise UniRef30_2023_02 par défaut. Cette version peut être téléchargée par ce script. Vous pouvez également écraser le chemin par défaut de la base de données uniref30 à l'aide de l'indicateur --uniref30_database_path de create_individual_features.py.
Note
Étant donné que l'installation locale de toutes les bases de données génétiques prend de la place, vous pouvez également utiliser les bases de données MMseqs2 et ColabFold exécutées à distance. Suivez les instructions correspondantes. Cependant, pour qu'AlphaPulldown fonctionne, vous devez télécharger les paramètres stockés dans le répertoire params/ de la base de données AlphaFold.
AlphaPulldown est disponible sous forme de pipeline Snakemake, vous permettant d'exécuter séquentiellement (1) la génération de MSA et de fonctionnalités de modèle, (2) la prédiction de structure et (3) l'analyse des résultats sans intervention manuelle entre les étapes. Pour plus de détails, veuillez vous référer au référentiel AlphaPulldownSnakemake .
Avertissement
La version Snakemake d'AlphaPulldown diffère légèrement de l'AlphaPulldown conventionnel basé sur des scripts en termes de spécifications de fichier d'entrée.
Avant l'installation, assurez-vous que votre version de Python est au moins 3.10.
python3 --version
Installer les dépendances
pip install Snakemake==7.32.4 Snakedeploy==0.10.0 pulp==2.7 clic==8.1 cookiecutter==2.6
Configuration du cluster Snakemake
Afin de permettre à Snakemake de s'interfacer avec un cluster de calcul, nous allons utiliser le Snakemake-Profile pour SLURM. Si vous ne travaillez pas sur un cluster SLURM, vous pouvez trouver ici des profils pour différentes architectures. Ce qui suit créera un profil qui peut être utilisé avec Snakemake et vous demandera des informations supplémentaires.
clone git https://github.com/Snakemake-Profiles/slurm.git
profile_dir="${HOME}/.config/snakemake"mkdir -p "$profile_dir"template="gh:Snakemake-Profiles/slurm"cookiecutter --output-dir "$profile_dir" "$template"Pendant le processus de configuration, vous serez invité à répondre à plusieurs questions de configuration. Vous trouverez ci-dessous les questions et les réponses recommandées :
profile_name [slurm]: slurm_noSidecar
Select use_singularity: 1 (Faux)
Select use_conda: 1 (Faux)
jobs [500]: (Appuyez sur Entrée pour accepter la valeur par défaut)
restart_times [0]: (Appuyez sur Entrée pour accepter la valeur par défaut)
max_status_checks_per_second [10]: (Appuyez sur Entrée pour accepter la valeur par défaut)
max_jobs_per_second [10]: (Appuyez sur Entrée pour accepter la valeur par défaut)
latency_wait [5]: 30
Select print_shell_commands: 1 (Faux)
sbatch_defaults []: qos=nœuds faibles=1
Select cluster_sidecar: 2 (non)
cluster_name []: (Appuyez sur Entrée pour laisser vide)
cluster_jobname [%r_%w]: (Appuyez sur Entrée pour accepter la valeur par défaut)
cluster_logpath [logs/slurm/%r/%j]: (Appuyez sur Entrée pour accepter la valeur par défaut)
cluster_config []: (Appuyez sur Entrée pour laisser vide)
Après avoir répondu à ces invites, votre profil Slurm nommé slurm_noSidecar pour Snakemake sera configuré comme spécifié.
Singularité (probablement déjà installée) : ce pipeline utilise des conteneurs pour la reproductibilité. Si vous travaillez sur la singularité du cluster EMBL est déjà installée et vous pouvez ignorer cette étape. Sinon, veuillez installer Singularity à l'aide du guide officiel de Singularity.
Télécharger le pipeline : cela téléchargera la version spécifiée par '--tag' du pipeline Snakemake et créera le référentiel AlphaPulldownSnakemake ou tout autre nom de votre choix.
Snakedeploy Déploiement-Workflow https://github.com/KosinskiLab/AlphaPulldownSnakemake AlphaPulldownSnakemake --tag 1.4.0cd AlphaPulldownSnakemake
Note
Si vous souhaitez utiliser la dernière version de GitHub, remplacez --tag XXX par --branch main
Installer le package CCP4 : Pour installer le logiciel nécessaire à l'étape d'analyse, veuillez suivre ces instructions :
Téléchargez l'image dite de singularité avec notre logiciel d'analyse
docker d'extraction de singularité://kosinskilab/fold_analysis:latest singularité build --sandboxfold_analysis_latest.sif
Téléchargez CCP4 depuis https://www.ccp4.ac.uk/download/#os=linux et copiez-le sur votre serveur
tar xvzf ccp4-9.0.003-linux64.tar.gzcd ccp4-9 cp bin/pisa bin/sc/software/ cp /lib/* /software/lib64/
Créez une nouvelle singularité avec CCP4 inclus
cdsingularity buildfold_analysis_latest_withCCP4.sif
Il devrait créer fold_analysis_latest_withCCP4.sif .
Vous pouvez supprimer le
Ajustez config/config.yaml pour votre cas d'utilisation particulier.
Si vous souhaitez utiliser CCP4 pour l'analyse, ouvrez config/config.yaml dans un éditeur de texte et modifiez le chemin d'accès au conteneur d'analyse comme suit :
Analysis_container : "/path/to/fold_analysis_latest_withCCP4.sif"
input_files Cette variable contient le chemin d'accès à votre feuille d'échantillon, où chaque ligne correspond à un travail de pliage. Pour ce pipeline, nous utilisons la spécification de format suivante :
protein:N:start-stop[_protein:N:start-stop]*
où protéine est un chemin vers un fichier avec l'extension « .fasta » ou un identifiant uniprot, N est le nombre de monomères pour cette protéine particulière et start et stop sont les résidus qui doivent être prédits. Cependant, seules les protéines sont nécessaires, N, start et stop peuvent être omis. Par conséquent, les tâches de repliement suivantes pour l'exemple de protéine contenant les résidus 1 à 50 sont équivalentes :
example:2 example_example example:2:1-50 example:1-50_example:1-50 example:1:1-50_example:1:1-50
Ce format s'étend de la même manière pour le repliement des hétéromères :
example1_example2
En supposant que vous disposez de deux exemples de feuilles config/sample_sheet1.csv et config/sample_sheet2.csv. Ce qui suit équivaudrait à calculer tout contre tout dans sample_sheet1.csv :
input_files : - config/sample_sheet1.csv - config/sample_sheet1.csv
tandis que l'extrait ci-dessous équivaudrait à calculer le menu déroulant entre sample_sheet1.csv et sample_sheet2.csv
input_files : - config/sample_sheet1.csv - config/sample_sheet2.csv
Ce format peut être étendu à autant de fichiers que vous le souhaitez, mais gardez à l'esprit que le nombre de plis augmentera considérablement.
input_files : - config/sample_sheet1.csv - config/sample_sheet2.csv - ...
alphafold_data_directory Il s'agit du chemin d'accès à votre base de données alphafold.
output_directory Snakemake écrira la sortie du pipeline dans ce répertoire. S'il n'existe pas, il sera créé.
save_msa, use_precomputed_msa, prédictions_per_model, number_of_recycles, report_cutoff Arguments de ligne de commande qui ont été précédemment transmis à run_multimer_jobs.py et create_notebook.py (report_cutoff) d'AlphaPulldown.
alphafold_inference_threads, alphafold_inference Paramètres spécifiques à Slurm qui n'ont pas besoin d'être modifiés par des utilisateurs non experts.
only_generate_features Si défini sur True, s'arrête après la génération des fonctionnalités et n'effectue pas de prédiction de structure ni de reporting.
Après avoir suivi les étapes d'installation et de configuration, vous êtes maintenant prêt à exécuter le pipeline Snakemake. Pour ce faire, accédez au répertoire du pipeline cloné et exécutez :
faire un serpent --use-singularité --singularity-args "-B /scratch:/scratch -B /g/kosinski:/g/kosinski --nv " --emplois 200 --restart-times 5 --profile slurm_noSidecar --rerun-incomplet --rerun-triggers mtime --latence-attente 30 -n
Voici un aperçu de ce que fait chaque argument :
--use-singularity : Permet l'utilisation de conteneurs Singularity. Cela permet la reproductibilité et l’isolation de l’environnement du pipeline.
--singularity-args : Spécifie les arguments passés directement à Singularity. Dans l'exemple fourni :
-B /scratch:/scratch et -B /g/kosinski:/g/kosinski : Ce sont des points de montage de liaison. Ils rendent les répertoires de votre système hôte accessibles dans le conteneur Singularity. --nv garantit que le conteneur peut utiliser les GPU des hôtes.
--profile name_of_your_profile : Spécifie le profil Snakemake à utiliser (par exemple, le profil SLURM que vous avez configuré pour l'exécution du cluster).
--rerun-triggers mtime : Réexécute une tâche si un fichier spécifique (déclencheur) a été modifié plus récemment que la sortie de la tâche. Ici, mtime vérifie l'heure de modification du fichier.
--jobs 500 : Permet de soumettre jusqu'à 500 jobs simultanément au cluster.
--restart-times 10 : Spécifie que les tâches peuvent être automatiquement redémarrées jusqu'à 10 fois en cas d'échec.
--rerun-incomplete : Force la réexécution de toutes les tâches restées incomplètes lors des exécutions précédentes de Snakemake.
--latency-wait 30 : attend 30 secondes après la fin d'une étape pour vérifier l'existence des fichiers de sortie attendus. Cela peut être utile dans les systèmes de fichiers avec des latences élevées.
-n : indicateur d'exécution à sec. Cela permet à Snakemake d'afficher les commandes qu'il exécuterait sans les exécuter réellement. C'est utile pour les tests. Pour exécuter le pipeline réellement, supprimez simplement cet indicateur.
L'exécution de la commande ci-dessus effectuera la soumission des tâches suivantes au cluster :
AlphaPulldown peut être utilisé comme un ensemble de scripts pour chaque étape particulière.
create_individual_features.py : génère plusieurs alignements de séquences (MSA), identifie les modèles structurels et stocke les résultats dans des fichiers de fonctionnalités monomères .pkl .
run_multimer_jobs.py : Exécute la prédiction des structures.
create_notebook.py et alpha-analysis.sif : préparent respectivement un bloc-notes Jupyter interactif et un tableau de résultats.
Tout d'abord , installez Anaconda et créez un environnement AlphaPulldown, rassemblant les dépendances nécessaires. Nous recommandons d'utiliser mamba pour accélérer la résolution des dépendances :
conda create -n AlphaPulldown -c omnia -c bioconda -c conda-forge python==3.11 openmm==8.0 pdbfixer==1.9 kalign2 hhsuite hmmer modelcif
source activer AlphaPulldown
Cela fonctionne généralement, mais sur certains systèmes informatiques, les utilisateurs peuvent préférer utiliser d'autres versions ou des versions optimisées de HMMER et HH-suite déjà installées.
Activez l'environnement AlphaPulldown et installez AlphaPulldown :
source activer AlphaPulldown python3 -m pip install alphapulldown
pip install -U "jax[cuda12]"
Note
Pour les anciennes versions d'AlphaFold : Si vous n'avez pas mis à jour vos bases de données selon les exigences d'AlphaFold 2.3.0, vous pouvez toujours utiliser AlphaPulldown avec votre ancienne version de la base de données AlphaFold. Merci de suivre les instructions d'installation sur la branche dédiée.
Installer le package CCP4 : Pour installer le logiciel nécessaire à l'étape d'analyse, veuillez suivre ces instructions :
docker d'extraction de singularité://kosinskilab/fold_analysis:latest singularity build --sandboxfold_analysis_latest.sif# Téléchargez celui du haut depuis https://www.ccp4.ac.uk/download/#os=linuxtar xvzf ccp4-9.0.003-linux64.tar.gzcd ccp4-9 cp bin/pisa bin/sc /software/ cp /lib/* /software/lib64/ construction de singularité
Assurez-vous d'avoir installé PyTorch correspondant à la version CUDA dont vous disposez. Ici, nous prendrons CUDA 11.7 et PyTorch 1.13.0 comme exemple :
pip install torch==1.13.0+cu117 --extra-index-url https://download.pytorch.org/whl/cu117
Compilez UniCore.
source activer AlphaPulldown
clone git https://github.com/dptech-corp/Uni-Core.gitcd Uni-Core
python setup.py installer --disable-cuda-ext
# tester si Unicore est installé avec succèspython -c "import unicore"L'avertissement suivant peut s'afficher, mais ce n'est pas grave :
fused_multi_tensor is not installed corrected
fused_rounding is not installed corrected
fused_layer_norm is not installed corrected
fused_softmax is not installed corrected Téléchargez les points de contrôle PyTorch depuis Zenodo, décompressez-le, vous devriez alors obtenir un fichier nommé : AlphaLink-Multimer_SDA_v3.pt
Uniquement pour les développeurs qui souhaitent modifier les codes d'AlphaPulldown et tester leurs modifications. Veuillez ajouter votre clé SSH à votre compte GitHub
Cloner le dépôt GitHub
git clone --recurse-submodules [email protected]:KosinskiLab/AlphaPulldown.gitcd AlphaPulldown initialisation du sous-module git mise à jour du sous-module git
Créez l'environnement Conda comme décrit dans Créer un environnement Anaconda
Installez le package AlphaPulldown et ajoutez ses sous-modules à l'environnement Conda (ne fonctionne pas si vous souhaitez mettre à jour les dépendances)
source activer AlphaPulldowncd AlphaPulldown pip install .pip install -e . --no-deps pip install -e ColabFold --no-deps pip install -e alphafold --no-deps
Vous ne devez le faire qu'une seule fois.
Lorsque vous souhaitez développer, activez l'environnement, modifiez des fichiers et les modifications devraient être automatiquement reconnues.
Testez votre package pendant le développement en utilisant des tests dans test/ , par exemple :
pip installer pytest pytest -s test/ pytest -s test/test_predictions_slurm.py pytest -s test/test_features_with_templates.py :: TestCreateIndividualFeaturesWithTemplates :: test_1a_run_features_generation
Avant de pousser vers la télécommande ou de soumettre une pull request :
pip install .pytest -s test/
pour installer le package et tester. Pytest pour les prédictions ne fonctionne que si SLURM est disponible. Vérifiez les fichiers journaux créés dans votre répertoire actuel.
Note
Si vous travaillez avec des protéines provenant d'organismes modèles, vous pouvez télécharger directement les fichiers de fonctionnalités à partir de la base de données de fonctionnalités AlphaPulldown et ignorer cette étape.
Ceci est un exemple général d'utilisation de create_individual_features.py . Pour plus d'informations sur l'exécution de tâches spécifiques ou l'exécution parallèle sur un cluster, veuillez vous référer aux sections correspondantes de ce chapitre.
À cette étape, vous devez fournir un fichier au format FASTA contenant toutes les séquences protéiques qui seront utilisées pour la prédiction complexe.
Exemple de fichier FASTA ( sequences.fasta ) :
>proteinA
SEQUENCEOFPROTEINA
>proteinB
SEQUENCEOFPROTEINB Activez l'environnement AlphaPulldown et exécutez le script create_individual_features.py comme suit :
source activer AlphaPulldown create_individual_features.py --fasta_paths=--data_dir= --output_dir= --max_template_date=
Au lieu de
Au lieu de
Au lieu de
Une date dans le drapeau --max_template_date est nécessaire pour restreindre la recherche de structures protéiques déposées avant la date indiquée. Sauf si la date est postérieure à la date de la dernière mise à jour de votre base de données génomique locale, le script recherchera des modèles parmi toutes les structures disponibles.
Le script de calcul des fonctionnalités create_individual_features.py comporte plusieurs FLAGS facultatifs :
--[no]save_msa_files : Par défaut, False pour enregistrer l'étape de stockage mais peut être modifié en True . S'il est défini sur True , le programme créera un dossier individuel pour chaque protéine. Le répertoire de sortie ressemblera à :
output_dir
|- proteinA.pkl
|- proteinA
|- uniref90_hits.sto
|- pdb_hits.sto
|- etc.
|- proteinB.pkl
|- proteinB
|- uniref90_hits.sto
|- pdb_hits.sto
|- etc. Si save_msa_files=False alors le output_dir ressemblera à :
output_dir
|- proteinA.pkl
|- proteinB.pkl --[no]use_precomputed_msas : La valeur par défaut est False . Cependant, si vous disposez déjà de fichiers MSA pour vos protéines, veuillez définir le paramètre sur True et organiser vos fichiers MSA au format ci-dessous :
example_directory
|- proteinA
|- uniref90_hits.sto
|- pdb_hits.sto
|- ***.a3m
|- etc
|- proteinB
|- ***.sto
|- etc Ensuite, dans la ligne de commande, définissez output_dir=/path/to/example_directory .
--[no]skip_existing : La valeur par défaut est False mais si vous avez déjà exécuté la 1ère étape pour certaines protéines et que vous ajoutez maintenant de nouvelles protéines à la liste, vous pouvez remplacer skip_existing par True dans la ligne de commande pour éviter de réexécuter la même procédure pour la précédente. protéines calculées.
--seq_index : La valeur par défaut est None et le programme exécutera les prédictions une par une dans les fichiers donnés. Cependant, vous pouvez définir seq_index sur un nombre différent si vous souhaitez exécuter un tableau de tâches en parallèle, le programme n'exécutera alors que la tâche correspondante spécifiée par seq_index . par exemple, le programme ne calcule les caractéristiques de la 1ère protéine de votre fichier FASTA que si seq_index est défini sur 1. Voir également le script Slurm sbatch ci-dessus pour un exemple de comment l'utiliser pour une exécution parallèle. ❗ seq_index commence à 1.
--[no]use_mmseqs2 : Utiliser mmseqs2 à distance ou non. La valeur par défaut est Faux.
FLAGS liés au mode TrueMultimer :
--path_to_mmt : Chemin d'accès au répertoire contenant les fichiers mmCIF de modèles multimériques.
--description_file : Chemin d'accès au fichier texte avec les descriptions pour générer des fonctionnalités. Veuillez noter que la première colonne doit être une copie exacte de la description de la protéine issue de vos fichiers FASTA. Veuillez envisager de les raccourcir dans les fichiers FASTA en utilisant votre éditeur de texte préféré pour plus de commodité. Ces noms serviront à générer des fichiers pickle avec des fonctionnalités monomères ! Le fichier description.csv du complexe NS1-P85B devrait ressembler à :
>sp|P03496|NS1_I34A1,3L4Q.cif,A
>sp|P23726|P85B_BOVIN,3L4Q.cif,CDans cet exemple, nous désignons la protéine NS1 par chaîne A et la protéine P85B par chaîne C dans la matrice multimérique 3L4Q.cif.
Veuillez noter que votre modèle sera renommé en un code PDB tiré de _entry_id . Si vous utilisez un fichier *.pdb au lieu de *.cif, AlphaPulldown tentera d'abord d'analyser le code PDB du fichier. Ensuite, il vérifiera si le nom du fichier comporte 4 lettres. Si ce n'est pas le cas, il générera un code aléatoire à 4 lettres et l'utilisera comme code PDB.
--threshold_clashes : seuil de chevauchement VDW pour identifier les conflits. Le chevauchement VDW entre deux atomes est défini comme la somme de leurs rayons VDW moins la distance entre leurs centres. Si le chevauchement dépasse ce seuil, les deux atomes sont considérés comme étant en conflit. Un seuil positif correspond à la mesure dans laquelle les surfaces VDW peuvent s'interpénétrer avant de considérer que les atomes sont en conflit. (par défaut : 1000, c'est-à-dire pas de seuil, pour le seuillage, utilisez 0,6-0,9).
--hb_allowance : tolérance supplémentaire pour la liaison hydrogène (par défaut : 0,4) utilisée pour identifier les résidus conflictuels à éliminer d'un modèle multimère. Une tolérance > 0 reflète l'observation selon laquelle les atomes partageant une liaison hydrogène peuvent se rapprocher les uns des autres par rapport à leurs rayons VDW. L'allocation n'est soustraite que pour les paires composées d'un donneur (ou d'hydrogène porté par un donneur) et d'un accepteur. Cela équivaut à utiliser des rayons plus petits pour caractériser les interactions entre liaisons hydrogène.
--plddt_threshold : Seuil du score pLDDT (par défaut : 0) à supprimer d'un modèle multimérique (tous les résidus avec pLDDT>plddt_threshold sont supprimés et modélisés à partir de zéro). Peut être utilisé uniquement lorsque les modèles multimériques sont des modèles générés par AlphaFold.
--new_uniclust_dir : Veuillez utiliser ceci si vous souhaitez écraser le chemin par défaut de la base de données uniclust.
--[no]use_hhsearch : Utilisez hhsearch au lieu de hmmsearch lorsque vous recherchez un modèle de structure. La valeur par défaut est Faux.
--[no]multiple_mmts : Utilisez plusieurs modèles multimériques par chaîne. La valeur par défaut est Faux.
Le résultat de l'exécution create_individual_features.py correspond aux caractéristiques au format pickle pour chaque protéine du fichier FASTA d'entrée (par exemple, sequence_name_A.pkl et sequence_name_B.pkl ) stocké dans output_dir .
Note
Le nom des cornichons sera le même que les descriptions des séquences dans les fichiers FASTA (par exemple >protein_A dans le fichier FASTA donnera proteinA.pkl ). Notez que les symboles spéciaux tels que | : ; # , après > sera remplacé par _ .
Passez à l'étape suivante 2.1 Exécution de base.
Si vous exécutez AlphaPulldown sur un cluster d'ordinateurs, vous souhaiterez peut-être exécuter la création de fonctionnalités en parallèle. Nous fournissons ici un exemple de code adapté à un cluster qui utilise SLURM Workload Manager.
Pour l'exemple suivant, nous utiliserons example_2_sequences.fasta comme entrée.
Créez le script create_individual_features_SLURM.sh et placez-y le code suivant à l'aide de vi, nano ou de tout autre éditeur de texte. Remplacez les paramètres d'entrée par les arguments appropriés pour le script create_individual_features.py comme décrit dans Exécution de base ou tout autre type d'exécution que vous avez l'intention d'exécuter :
#!/bin/bash#Une exécution typique prend quelques heures mais peut être beaucoup plus longue#SBATCH --job-name=array#SBATCH --time=10:00:00#log files:#SBATCH -e logs/ create_individual_features_%A_%a_err.txt#SBATCH -o logs/create_individual_features_%A_%a_out.txt#qos définit la priorité#SBATCH --qos=low#Limiter l'exécution à un seul nœud#SBATCH -N 1#Ajustez cela en fonction de node#SBATCH --ntasks=8#SBATCH --mem=64000chargement du module HMMER/3.4-gompi-2023a chargement du module HH-suite/3.3.0-gompi-2023aeval "$(conda shell.bash hook)" chargement du module CUDA/11.8.0 charge du module cuDNN/8.7.0.84-CUDA-11.8.0 conda activate AlphaPulldown# PERSONNALISEZ LES PARAMÈTRES DE SCRIPT SUIVANTS POUR VOTRE TÂCHE SPÉCIFIQUE :####create_individual_features.py --fasta_paths=exemple_1_sequences.fasta --data_dir=/scratch/AlphaFold_DBs/2.3.2 / --output_dir=/scratch/monrép/test_AlphaPulldown/ --max_template_date=2050-01-01 --skip_existing=Vrai --seq_index=$SLURM_ARRAY_TASK_ID#####
Rendez le script exécutable en exécutant :
chmod +x create_individual_features_SLURM.sh
Ensuite, exécutez les commandes suivantes, en remplaçant
mkdir logs#Comptez le nombre de jobs correspondant au nombre de séquences :count=`grep ">"| wc -l`#Exécuter le tableau de tâches, 100 tâches à la fois :sbatch --array=1-$count%100 create_individual_features_SLURM.sh
Exemple pour deux fichiers (Pour plus de fichiers, créez des variables count3 , count4 , etc. et ajoutez-les à la somme des counts) :
mkdir logs#Comptez le nombre de jobs correspondant au nombre de séquences :count1=`grep ">"| wc -l`count2=`grep ">" | wc -l`count=$(( $count1 + $count2 )) #Exécuter le tableau de tâches, 100 tâches à la fois :sbatch --array=1-$count%100 create_individual_features_SLURM.sh
Passez à l'étape suivante 2.2 Exemple d'exécution avec SLURM (cluster EMBL).
MMseqs2 est une autre méthode de recherche d'homologues et de génération de MSA. Il offre une alternative aux HMMER et HHblits par défaut utilisés par AlphaFold. Les résultats de ces différentes approches pourraient conduire à des prédictions légèrement différentes de la structure des protéines en raison des variations dans les informations évolutives capturées au sein des MSA. AlphaPulldown prend en charge la mise en œuvre de la recherche MMseqs2 effectuée par ColabFold, qui fournit également un serveur Web pour la génération MSA, aucune installation locale de bases de données n'est donc nécessaire.
Citer : Si vous utilisez MMseqs2, n'oubliez pas de citer : Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold : Rendre le repliement des protéines accessible à tous. Méthodes naturelles (2022) doi : 10.1038/s41592-022-01488-1
ATTENTION : Pour éviter de surcharger le serveur distant, ne soumettez pas un grand nombre de tâches simultanément. Si vous souhaitez calculer les MSA pour de nombreuses séquences, veuillez utiliser MMseqs2 localement.
Pour exécuter create_individual_features.py à l'aide de MMseqs2 à distance, ajoutez l'indicateur --use_mmseqs2=True :
source activer AlphaPulldown create_individual_features.py --fasta_paths=--data_dir= --output_dir= --use_mmseqs2=Vrai --max_template_date=
Une fois l'exécution du script terminée, votre output_dir ressemblera à ceci :
output_dir
|-proteinA.a3m
|-proteinA_env/
|-proteinA.pkl
|-proteinB.a3m
|-proteinB_env/
|-proteinB.pkl
...Passez à l'étape suivante 2.1 Exécution de base.
AlphaPulldown ne fournit PAS d'interface ou de code pour exécuter MMseqs2 localement, et n'installera PAS MMseqs2 ou tout autre programme requis. L'utilisateur doit installer MMseqs2, les bases de données ColabFold, la recherche ColabFold et les autres dépendances requises et exécuter d'abord les alignements MSA. Un exemple de guide peut être trouvé sur ColabFold GitHub.
Supposons que vous ayez exécuté avec succès MMseqs2 localement à l'aide du programme colab_search ; il générera un fichier A3M pour chaque protéine qui vous intéresse. Ainsi, votre output_dir devrait ressembler à ceci :
output_dir
|-0.a3m
|-1.a3m
|-2.a3m
|-3.a3m
... Ces fichiers a3m de colabfold_search portent des noms peu pratiques. Ainsi, nous avons fourni un script rename_colab_search_a3m.py pour vous aider à renommer tous ces fichiers. Téléchargez le script depuis https://github.com/KosinskiLab/AlphaPulldown/blob/main/alphapulldown/scripts/rename_colab_search_a3m.py et exécutez :
cd rép_sortie python rename_colab_search_a3m.py path_to_fasta_file_you_used_as_input_for_colabfold_search
Votre output_dir deviendra alors :
output_dir
|-proteinA.a3m
|-proteinB.a3m
|-proteinC.a3m
|-proteinD.a3m
... Ici, proteinA , proteinB , etc. correspondent aux noms dans votre fichier FASTA d'entrée (par exemple, >proteinA vous donnera proteinA.a3m , >proteinB vous donnera proteinB.a3m , etc.).
REMARQUE : Vous pouvez également fournir votre propre fichier MSA personnalisé au format
.a3mau lieu d'utiliser les fichiers créés par MMSeq2 ou le standard HHMER. Placez les fichiers correctement nommés dans le répertoire de sortie et utilisez le code comme suit.
Après cela, retournez dans le répertoire de votre projet avec le fichier FASTA d'origine et pointez sur ce répertoire dans la commande :
source activer AlphaPulldown create_individual_features.py --fasta_paths=--data_dir= --output_dir= --skip_existing=Faux --use_mmseqs2=Vrai --seq_index=
AlphaPulldown recherchera automatiquement les fichiers a3m correspondants à chaque protéine. Au final, votre output_dir ressemblera à :
output_dir
|-proteinA.a3m
|-proteinA.pkl
|-proteinB.a3m
|-proteinB.pkl
|-proteinC.a3m
|-proteinC.pkl
...<
