Skip to content

seoklab/alphafold

BranchesTags
 
 

Repository files navigation

header

AlphaFold

This package provides an implementation of the inference pipeline of AlphaFold v2. For simplicity, we refer to this model as AlphaFold throughout the rest of this document.

We also provide:

  1. An implementation of AlphaFold-Multimer. This represents a work in progress and AlphaFold-Multimer isn't expected to be as stable as our monomer AlphaFold system. Read the guide for how to upgrade and update code.
  2. The technical note containing the models and inference procedure for an updated AlphaFold v2.3.0.
  3. A CASP15 baseline set of predictions along with documentation of any manual interventions performed.

Any publication that discloses findings arising from using this source code or the model parameters should cite the AlphaFold paper and, if applicable, the AlphaFold-Multimer paper.

Please also refer to the Supplementary Information for a detailed description of the method.

You can use a slightly simplified version of AlphaFold with this Colab notebook or community-supported versions (see below).

If you have any questions, please contact the AlphaFold team at [email protected].

CASP14 predictions

Seoklab version of AlphaFold has few changes:

  • Major changes
  • Minor changes
    • Add runner script alphafold.
    • Support "resuming"; this version will automatically try to use the previous results, if they exists. You can force everything to run again by passing --overwrite flag from the command line.
    • Add command-line option for number of recycling iterations (seoklab/alphafold#1).
    • Make command line interface more user-friendly.
    • Code refactoring.

Installation and running your first prediction

You will need a machine running Linux, AlphaFold does not support other operating systems. Full installation requires up to 3 TB of disk space to keep genetic databases (SSD storage is recommended) and a modern NVIDIA GPU (GPUs with more memory can predict larger protein structures).

Please follow these steps:

  1. Clone this repository, then run ./install.sh. The script requires wget to run. Few variables could change the behavior of the script, namely:

    • $CONDA_PREFIX: The path for the newly-installed miniconda. Defaults to /opt/conda (for system-wide installations).
    • $SUDO: Either y or n. Defaults to y. If set to y, then the script will try to install AlphaFold system-wide, invoking sudo a few times. Please be careful for running this script in SUDO mode. Even though this script has been tested a few times, it is NOT fully tested for all types of Linux distros. (Currently tested on Ubuntu Server 16.04 LTS and Ubuntu Server 20.04 LTS)

  2. Download genetic databases and model parameters:

    • Install aria2c. On most Linux distributions it is available via the package manager as the aria2 package (on Debian-based distributions this can be installed by running sudo apt install aria2).

    • Please use the script scripts/download_all_data.sh to download and set up full databases. This may take substantial time (download size is 556 GB), so we recommend running this script in the background:

    scripts/download_all_data.sh <DOWNLOAD_DIR> > download.log 2> download_all.log &

  3. Run alphafold script with FASTA file(s) containing the protein sequence(s) for which you wish to predict the structure. AlphaFold will search for the available templates before the date specified by the --max_template_date parameter (default to all pdb files); this could be used to avoid certain templates during modeling.

    alphafold your_protein.fasta [--max_template_date=2022-01-01]

  4. Once the run is over, the output directory shall contain predicted structures of the target protein. Please check the documentation below for additional options and troubleshooting tips.

Genetic databases

This step requires rsync and aria2c to be installed on your machine.

AlphaFold needs multiple genetic (sequence) databases to run:

We provide a script scripts/download_all_data.sh that can be used to download and set up all of these databases:

  • Recommended default:

    scripts/download_all_data.sh <DOWNLOAD_DIR>

    will download the full databases.

  • With reduced_dbs parameter:

    scripts/download_all_data.sh <DOWNLOAD_DIR> reduced_dbs

    will download a reduced version of the databases to be used with the reduced_dbs database preset. This shall be used with the corresponding AlphaFold parameter --db_preset=reduced_dbs later during the AlphaFold run (please see AlphaFold parameters section).

📒 The data should be downloaded into $ALPHAFOLD_HOME/data. If you have chosen the other directory for the data to live, then it must be explicitly passed to the downloader script as a command line argument. The script will then automatically create a symlink pointing to the target directory at $ALPHAFOLD_HOME/data.

We don't provide exactly the database versions used in CASP14 – see the note on reproducibility. Some of the databases are mirrored for speed, see mirrored databases.

📒 Note: The total download size for the full databases is around 556 GB and the total size when unzipped is 2.62 TB. Please make sure you have a large enough hard drive space, bandwidth and time to download. We recommend using an SSD for better genetic search performance.

📒 Note: If the download directory and datasets don't have full read and write permissions, it can cause errors with the MSA tools, with opaque (external) error messages. Please ensure the required permissions are applied, e.g. with the sudo chmod 755 --recursive "$DOWNLOAD_DIR" command.

The download_all_data.sh script will also download the model parameter files. Once the script has finished, you should have the following directory structure:

$DOWNLOAD_DIR/                             # Total: ~ 2.62 TB (download: 556 GB)
    bfd/                                   # ~ 1.8 TB (download: 271.6 GB)
        # 6 files.
    mgnify/                                # ~ 120 GB (download: 67 GB)
        mgy_clusters_2022_05.fa
    params/                                # ~ 5.3 GB (download: 5.3 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/                             # ~ 238 GB (download: 43 GB)
        mmcif_files/
            # About 199,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/                              # ~ 206 GB (download: 52.5 GB)
        # 7 files.
    uniprot/                               # ~ 105 GB (download: 53 GB)
        uniprot.fasta
    uniref90/                              # ~ 67 GB (download: 34 GB)
        uniref90.fasta

bfd/ is only downloaded if you download the full databases, and small_bfd/ is only downloaded if you download the reduced databases.

Model parameters

While the AlphaFold code is licensed under the Apache 2.0 License, the AlphaFold parameters and CASP15 prediction data are made available under the terms of the CC BY 4.0 license. Please see the Disclaimer below for more detail.

The AlphaFold parameters are available from https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar, and are downloaded as part of the scripts/download_all_data.sh script. This script will download parameters for:

  • 5 models which were used during CASP14, and were extensively validated for structure prediction quality (see Jumper et al. 2021, Suppl. Methods 1.12 for details).
  • 5 pTM models, which were fine-tuned to produce pTM (predicted TM-score) and (PAE) predicted aligned error values alongside their structure predictions (see Jumper et al. 2021, Suppl. Methods 1.9.7 for details).
  • 5 AlphaFold-Multimer models that produce pTM and PAE values alongside their structure predictions.

Updating existing installation

If you have a previous version you can either reinstall fully from scratch (remove everything and run the setup from scratch) or you can do an incremental update that will be significantly faster but will require a bit more work. Make sure you follow these steps in the exact order they are listed below:

  1. Update the code.
    • Go to the directory with the cloned AlphaFold repository and run git fetch origin main to get all code updates.
  2. Update the UniProt, UniRef, MGnify and PDB seqres databases.
    • Remove <DOWNLOAD_DIR>/uniprot.
    • Run scripts/download_uniprot.sh <DOWNLOAD_DIR>.
    • Remove <DOWNLOAD_DIR>/uniclust30.
    • Run scripts/download_uniref30.sh <DOWNLOAD_DIR>.
    • Remove <DOWNLOAD_DIR>/uniref90.
    • Run scripts/download_uniref90.sh <DOWNLOAD_DIR>.
    • Remove <DOWNLOAD_DIR>/mgnify.
    • Run scripts/download_mgnify.sh <DOWNLOAD_DIR>.
    • Remove <DOWNLOAD_DIR>/pdb_mmcif. It is needed to have PDB SeqRes and PDB from exactly the same date. Failure to do this step will result in potential errors when searching for templates when running AlphaFold-Multimer.
    • Run scripts/download_pdb_mmcif.sh <DOWNLOAD_DIR>.
    • Run scripts/download_pdb_seqres.sh <DOWNLOAD_DIR>.
  3. Update the model parameters.
    • Remove the old model parameters in <DOWNLOAD_DIR>/params.
    • Download new model parameters using scripts/download_alphafold_params.sh <DOWNLOAD_DIR>.
  4. Follow Running AlphaFold.

Using deprecated model weights

To use the deprecated v2.2.0 AlphaFold-Multimer model weights:

  1. Change SOURCE_URL in scripts/download_alphafold_params.sh to https://storage.googleapis.com/alphafold/alphafold_params_2022-03-02.tar, and download the old parameters.
  2. Change the _v3 to _v2 in the multimer MODEL_PRESETS in config.py.

To use the deprecated v2.1.0 AlphaFold-Multimer model weights:

  1. Change SOURCE_URL in scripts/download_alphafold_params.sh to https://storage.googleapis.com/alphafold/alphafold_params_2022-01-19.tar, and download the old parameters.
  2. Remove the _v3 in the multimer MODEL_PRESETS in config.py.

Running AlphaFold

Invoke the runner script alphafold with the fasta paths as arguments. Full configurations is as followings.

usage: alphafold [-h] [--helpfull] [--is_prokaryote_list IS_PROKARYOTE_LIST]
                 [--output_dir OUTPUT_DIR] [--overwrite]
                 [--model_cnt MODEL_CNT] [--nproc NPROC] [--jit]
                 [--max_sequence_identity MAX_SEQUENCE_IDENTITY]
                 [--heteromer_paired_msa]
                 [--max_template_date MAX_TEMPLATE_DATE] [--ensemble ENSEMBLE]
                 [--small_bfd] [--split_bfd_uniclust]
                 [--model_type MODEL_TYPE] [--state STATE]
                 [--num_multimer_predictions_per_model NUM_MULTIMER_PREDICTIONS_PER_MODEL]
                 [--num_recycle NUM_RECYCLE]
                 [--recycle_early_stop_tolerance RECYCLE_EARLY_STOP_TOLERANCE]
                 [--only_msa] [--models_to_relax MODELS_TO_RELAX]
                 [--use_gpu_relax] [--benchmark] [--debug] [--quiet]
                 [--data_dir DATA_DIR]
                 [--jackhmmer_binary_path JACKHMMER_BINARY_PATH]
                 [--hhblits_binary_path HHBLITS_BINARY_PATH]
                 [--hhsearch_binary_path HHSEARCH_BINARY_PATH]
                 [--hmmsearch_binary_path HMMSEARCH_BINARY_PATH]
                 [--hmmbuild_binary_path HMMBUILD_BINARY_PATH]
                 [--kalign_binary_path KALIGN_BINARY_PATH]
                 [--uniref90_database_path UNIREF90_DATABASE_PATH]
                 [--mgnify_database_path MGNIFY_DATABASE_PATH]
                 [--bfd_database_path BFD_DATABASE_PATH]
                 [--small_bfd_database_path SMALL_BFD_DATABASE_PATH]
                 [--uniref30_database_path UNIREF30_DATABASE_PATH]
                 [--uniprot_database_path UNIPROT_DATABASE_PATH]
                 [--pdb70_database_path PDB70_DATABASE_PATH]
                 [--pdb_seqres_database_path PDB_SEQRES_DATABASE_PATH]
                 [--template_mmcif_dir TEMPLATE_MMCIF_DIR]
                 [--obsolete_pdbs_path OBSOLETE_PDBS_PATH]
                 [--random_seed RANDOM_SEED]
                 fasta_paths [fasta_paths ...]

positional arguments:
  fasta_paths           Paths to FASTA files, each containing a prediction
                        target that will be folded one after another. If a
                        FASTA file contains multiple sequences, then it will
                        be folded as a multimer. Paths should be separated by
                        commas. All FASTA paths must have a unique basename as
                        the basename is used to name the output directories
                        for each prediction.

options:
  -h, --help            show this help message and exit
  --helpfull            show full help message and exit
  --is_prokaryote_list IS_PROKARYOTE_LIST
                        Optional for multimer system, not used by the single
                        chain system. This list should contain a boolean for
                        each fasta specifying true where the target complex is
                        from a prokaryote, and false where it is not, or where
                        the origin is unknown. These values determine the
                        pairing method for the MSA.
  --output_dir OUTPUT_DIR
                        Path to a directory that will store the results.
  --overwrite, --nooverwrite
                        Whether to re-build the features, even if the result
                        exists in the target directories.
  --model_cnt MODEL_CNT
                        Counts of models to use. Note that AlphaFold provides
                        5 pretrained models, so setting the count other than 5
                        is either redundant or insufficient configuration.
  --nproc NPROC         Maximum cpu count to use. Note that the actual cpu
                        load might be different than the configured value.
  --jit, --nojit        Whether to jit compile the alphafold model.
  --max_sequence_identity MAX_SEQUENCE_IDENTITY
                        Maximum sequence identity for template prefilter.
  --heteromer_paired_msa, --noheteromer_paired_msa
                        Whether to turn on msa pairing for heteromers. No-op
                        for monomers or homomers.
  --max_template_date MAX_TEMPLATE_DATE
                        Maximum template release date to consider(ISO-8601
                        format - i.e. YYYY-MM-DD). Important if folding
                        historical test sets.
  --ensemble ENSEMBLE   Choose ensemble count: note that AlphaFold recommends
                        1 ("full_dbs"), and the casp model have used 8 model
                        ensemblings ("casp14").
  --small_bfd, --nosmall_bfd
                        Whether to use smaller genetic database config.
  --split_bfd_uniclust, --nosplit_bfd_uniclust
                        Whether to run hhblits on the bfd and uniclust
                        databases separately. This is useful for some rare
                        cases where the hhblits fails when run on the two
                        databases simultaneously. Note that this option might
                        produce inconsistent results compared to the default
                        setting. No-op if --small_bfd is set.
  --model_type MODEL_TYPE
                        <normal|ptm|multimer|casp14>: Choose model type to use
                        - the casp14 equivalent model (normal), fined-tunded
                        pTM models (ptm), the alphafold-multimer (multimer),
                        and normal model with 8 model ensemblings (casp14).
                        Note that the casp14 preset is just an alias of
                        --model_type=normal --ensemble=8 option.
  --state STATE         <normal|active|intermediate|inactive>: Choose state
                        for GPCRs. Will be ignored if --pdb70_database_path
                        (monomer) or --pdb_seqres_database_path (multimer)
                        argument is set.
  --num_multimer_predictions_per_model NUM_MULTIMER_PREDICTIONS_PER_MODEL
                        How many predictions (each with a different random
                        seed) will be generated per model. E.g. if this is 2
                        and there are 5 models then there will be 10
                        predictions per input. Note: this FLAG only applies if
                        model_preset=multimer
  --num_recycle NUM_RECYCLE
                        How many recycling iterations to use.
  --recycle_early_stop_tolerance RECYCLE_EARLY_STOP_TOLERANCE
                        A negative value indicates that no early stopping will
                        occur, i.e. the model will always run `num_recycle`
                        number of recycling iterations. A positive value will
                        enable early stopping if the difference in pairwise
                        distances is less than the tolerance between recycling
                        steps. Applied only for multimer predictions.
  --only_msa, --noonly_msa
                        Whether to run only the MSA pipeline.
  --models_to_relax MODELS_TO_RELAX
                        <all|best|none>: The models to run the final
                        relaxation step on. If `all`, all models are relaxed,
                        which may be time consuming. If `best`, only the most
                        confident model is relaxed. If `none`, relaxation is
                        not run. Turning off relaxation might result in
                        predictions with distracting stereochemical violations
                        but might help in case you are having issues with the
                        relaxation stage.
  --use_gpu_relax, --nouse_gpu_relax
                        Whether to relax on GPU. Relax on GPU can be much
                        faster than CPU, so it is recommended to enable if
                        possible. Ignored if no GPU is available.
  --benchmark, --nobenchmark
                        Run multiple JAX model evaluations to obtain a timing
                        that excludes the compilation time, which should be
                        more indicative of the time required for inferencing
                        many proteins.
  --debug, --nodebug    Whether to print debug output.
  --quiet, --noquiet    Whether to silence non-warning messages. Takes
                        precedence over --debug option.
  --data_dir DATA_DIR   Path to directory of supporting data.
  --jackhmmer_binary_path JACKHMMER_BINARY_PATH
                        Path to the JackHMMER executable.
  --hhblits_binary_path HHBLITS_BINARY_PATH
                        Path to the HHblits executable.
  --hhsearch_binary_path HHSEARCH_BINARY_PATH
                        Path to the HHsearch executable.
  --hmmsearch_binary_path HMMSEARCH_BINARY_PATH
                        Path to the hmmsearch executable.
  --hmmbuild_binary_path HMMBUILD_BINARY_PATH
                        Path to the hmmbuild executable.
  --kalign_binary_path KALIGN_BINARY_PATH
                        Path to the Kalign executable.
  --uniref90_database_path UNIREF90_DATABASE_PATH
                        Path to the Uniref90 database for use by JackHMMER.
  --mgnify_database_path MGNIFY_DATABASE_PATH
                        Path to the MGnify database for use by JackHMMER.
  --bfd_database_path BFD_DATABASE_PATH
                        Path to the BFD database for use by HHblits.
  --small_bfd_database_path SMALL_BFD_DATABASE_PATH
                        Path to the BFD database for use by HHblits.
  --uniref30_database_path UNIREF30_DATABASE_PATH
                        Path to the UniRef30 database for use by HHblits.
  --uniprot_database_path UNIPROT_DATABASE_PATH
                        Path to the Uniprot database for use by JackHMMer.
  --pdb70_database_path PDB70_DATABASE_PATH
                        Path to the PDB70 database for use by HHsearch.
  --pdb_seqres_database_path PDB_SEQRES_DATABASE_PATH
                        Path to the PDB seqres database for use by hmmsearch.
  --template_mmcif_dir TEMPLATE_MMCIF_DIR
                        Path to a directory with template mmCIF structures,
                        each named <pdb_id>.cif
  --obsolete_pdbs_path OBSOLETE_PDBS_PATH
                        Path to file containing a mapping from obsolete PDB
                        IDs to the PDB IDs of their replacements.
  --random_seed RANDOM_SEED
                        The random seed for the data pipeline. By default,
                        this is randomly generated. Note that even if this is
                        set, Alphafold may still not be deterministic, because
                        processes like GPU inference are nondeterministic.

  1. After generating the predicted model, AlphaFold runs a relaxation step to improve local geometry. By default, only the best model (by pLDDT) is relaxed (--models_to_relax=best), but also all of the models (--models_to_relax=all) or none of the models (--models_to_relax=none) can be relaxed.

  2. The relaxation step can be run on GPU (faster, but could be less stable) or CPU (slow, but stable). This can be controlled with --enable_gpu_relax=true (default) or --enable_gpu_relax=false.

  3. AlphaFold can re-use MSAs (multiple sequence alignments) for the same sequence via --use_precomputed_msas=true option; this can be useful for trying different AlphaFold parameters. This option assumes that the directory structure generated by the first AlphaFold run in the output directory exists and that the protein sequence is the same.

Running AlphaFold-Multimer

All steps are the same as when running the monomer system, but you will have to

  • provide an input fasta with multiple sequences,
  • set --model_type=multimer,

An example that folds a protein complex multimer.fasta:

alphafold \
  --max_template_date=2020-05-14 \
  --model_type=multimer \
  multimer.fasta

Note that if any of the provided fasta files contains multiple chains, then the script automatically changes to multimer mode even if the other model type was explicitly given. Please provide single chains only to use other model types.

By default the multimer system will run 5 seeds per model (25 total predictions) for a small drop in accuracy you may wish to run a single seed per model. This can be done via the --num_multimer_predictions_per_model flag, e.g. set it to --num_multimer_predictions_per_model=1 to run a single seed per model.

AlphaFold prediction speed

The table below reports prediction runtimes for proteins of various lengths. We only measure unrelaxed structure prediction with three recycles while excluding runtimes from MSA and template search. When running docker/run_docker.py with --benchmark=true, this runtime is stored in timings.json. All runtimes are from a single A100 NVIDIA GPU. Prediction speed on A100 for smaller structures can be improved by increasing global_config.subbatch_size in alphafold/model/config.py.

No. residues Prediction time (s)
100 4.9
200 7.7
300 13
400 18
500 29
600 36
700 53
800 60
900 91
1,000 96
1,100 140
1,500 280
2,000 450
2,500 969
3,000 1,240
3,500 2,465
4,000 5,660
4,500 12,475
5,000 18,824

Examples

Below are examples on how to use AlphaFold in different scenarios.

Folding a monomer

Say we have a monomer with the sequence <SEQUENCE>. The input fasta should be:

>sequence_name
<SEQUENCE>

Then run the following command:

alphafold \
  --max_template_date=2021-11-01 \
  --model_type=normal \
  monomer.fasta

Folding a homomer

Say we have a homomer with 3 copies of the same sequence <SEQUENCE>. The input fasta should be:

>sequence_1
<SEQUENCE>
>sequence_2
<SEQUENCE>
>sequence_3
<SEQUENCE>

Then run the following command:

alphafold \
  --max_template_date=2021-11-01 \
  --model_type=multimer \
  homomer.fasta

Folding a heteromer

Say we have an A2B3 heteromer, i.e. with 2 copies of <SEQUENCE A> and 3 copies of <SEQUENCE B>. The input fasta should be:

>sequence_1
<SEQUENCE A>
>sequence_2
<SEQUENCE A>
>sequence_3
<SEQUENCE B>
>sequence_4
<SEQUENCE B>
>sequence_5
<SEQUENCE B>

Then run the following command:

alphafold \
  --max_template_date=2021-11-01 \
  --model_type=multimer \
  heteromer.fasta

Folding multiple monomers one after another

Say we have a two monomers, monomer1.fasta and monomer2.fasta.

We can fold both sequentially by using the following command:

alphafold \
  --max_template_date=2021-11-01 \
  --model_type=normal \
  monomer1.fasta monomer2.fasta

Folding multiple multimers one after another

Say we have a two multimers, multimer1.fasta and multimer2.fasta.

We can fold both sequentially by using the following command:

alphafold \
  --max_template_date=2021-11-01 \
  --model_type=multimer \
  multimer1.fasta multimer2.fasta

AlphaFold output

The outputs will be in the current directory for the default settings. They include the computed MSAs, unrelaxed structures, relaxed structures, ranked structures, raw model outputs, prediction metadata, and section timings. The directory will have the following structure:

<target_name>/
    features.pkl
    ranked_{0,1,2,3,4,...}.pdb
    ranking_debug.json
    relax_metrics.json
    relaxed_model_{1,2,3,4,5,...}.pdb
    result_model_{1,2,3,4,5,...}.pkl
    timings.json
    unrelaxed_model_{1,2,3,4,5,...}.pdb
    msas/
        (depending on configuration)
        [bfd_uniref_hits.a3m | small_bfd_hits.sto]
        mgnify_hits.sto
        uniref90_hits.sto

The contents of each output file are as follows:

  • features.pkl – A pickle file containing the input feature NumPy arrays used by the models to produce the structures.

  • unrelaxed_model_*.pdb – A PDB format text file containing the predicted structure, exactly as outputted by the model.

  • relaxed_model_*.pdb – A PDB format text file containing the predicted structure, after performing an Amber relaxation procedure on the unrelaxed structure prediction (see Jumper et al. 2021, Suppl. Methods 1.8.6 for details).

  • ranked_*.pdb – A PDB format text file containing the predicted structures, after reordering by model confidence. Here ranked_i.pdb should contain the prediction with the (i + 1)-th highest confidence (so that ranked_0.pdb has the highest confidence). To rank model confidence, we use predicted LDDT (pLDDT) scores (see Jumper et al. 2021, Suppl. Methods 1.9.6 for details). If --models_to_relax=all then all ranked structures are relaxed. If --models_to_relax=best then only ranked_0.pdb is relaxed (the rest are unrelaxed). If --models_to_relax=none, then the ranked structures are all unrelaxed.

  • ranking_debug.json – A JSON format text file containing the pLDDT values used to perform the model ranking, and a mapping back to the original model names.

  • relax_metrics.json – A JSON format text file containing relax metrics, for instance remaining violations.

  • timings.json – A JSON format text file containing the times taken to run each section of the AlphaFold pipeline.

  • msas/ - A directory containing the files describing the various genetic tool hits that were used to construct the input MSA.

  • result_model_*.pkl – A pickle file containing a nested dictionary of the various NumPy arrays directly produced by the model. In addition to the output of the structure module, this includes auxiliary outputs such as:

    • Distograms (distogram/logits contains a NumPy array of shape [N_res, N_res, N_bins] and distogram/bin_edges contains the definition of the bins).
    • Per-residue pLDDT scores (plddt contains a NumPy array of shape [N_res] with the range of possible values from 0 to 100, where 100 means most confident). This can serve to identify sequence regions predicted with high confidence or as an overall per-target confidence score when averaged across residues.
    • Present only if using pTM models: predicted TM-score (ptm field contains a scalar). As a predictor of a global superposition metric, this score is designed to also assess whether the model is confident in the overall domain packing.
    • Present only if using pTM models: predicted pairwise aligned errors (predicted_aligned_error contains a NumPy array of shape [N_res, N_res] with the range of possible values from 0 to max_predicted_aligned_error, where 0 means most confident). This can serve for a visualisation of domain packing confidence within the structure.

The pLDDT confidence measure is stored in the B-factor field of the output PDB files (although unlike a B-factor, higher pLDDT is better, so care must be taken when using for tasks such as molecular replacement).

This code has been tested to match mean top-1 accuracy on a CASP14 test set with pLDDT ranking over 5 model predictions (some CASP targets were run with earlier versions of AlphaFold and some had manual interventions; see our forthcoming publication for details). Some targets such as T1064 may also have high individual run variance over random seeds.

Inferencing many proteins

The provided inference script is optimized for predicting the structure of a single protein, and it will compile the neural network to be specialized to exactly the size of the sequence, MSA, and templates. For large proteins, the compile time is a negligible fraction of the runtime, but it may become more significant for small proteins or if the multi-sequence alignments are already precomputed. In the bulk inference case, it may make sense to use our make_fixed_size function to pad the inputs to a uniform size, thereby reducing the number of compilations required.

We do not provide a bulk inference script, but it should be straightforward to develop on top of the RunModel.predict method with a parallel system for precomputing multi-sequence alignments. Alternatively, this script can be run repeatedly with only moderate overhead.

Note on CASP14 reproducibility

AlphaFold's output for a small number of proteins has high inter-run variance, and may be affected by changes in the input data. The CASP14 target T1064 is a notable example; the large number of SARS-CoV-2-related sequences recently deposited changes its MSA significantly. This variability is somewhat mitigated by the model selection process; running 5 models and taking the most confident.

To reproduce the results of our CASP14 system as closely as possible you must use the same database versions we used in CASP. These may not match the default versions downloaded by our scripts.

For genetics:

For templates:

An alternative for templates is to use the latest PDB and PDB70, but pass the flag --max_template_date=2020-05-14, which restricts templates only to structures that were available at the start of CASP14.

Citing this work

If you use the code or data in this package, please cite:

@Article{AlphaFold2021,
  author  = {Jumper, John and Evans, Richard and Pritzel, Alexander and Green, Tim and Figurnov, Michael and Ronneberger, Olaf and Tunyasuvunakool, Kathryn and Bates, Russ and {\v{Z}}{\'\i}dek, Augustin and Potapenko, Anna and Bridgland, Alex and Meyer, Clemens and Kohl, Simon A A and Ballard, Andrew J and Cowie, Andrew and Romera-Paredes, Bernardino and Nikolov, Stanislav and Jain, Rishub and Adler, Jonas and Back, Trevor and Petersen, Stig and Reiman, David and Clancy, Ellen and Zielinski, Michal and Steinegger, Martin and Pacholska, Michalina and Berghammer, Tamas and Bodenstein, Sebastian and Silver, David and Vinyals, Oriol and Senior, Andrew W and Kavukcuoglu, Koray and Kohli, Pushmeet and Hassabis, Demis},
  journal = {Nature},
  title   = {Highly accurate protein structure prediction with {AlphaFold}},
  year    = {2021},
  volume  = {596},
  number  = {7873},
  pages   = {583--589},
  doi     = {10.1038/s41586-021-03819-2}
}

In addition, if you use the AlphaFold-Multimer mode, please cite:

@article {AlphaFold-Multimer2021,
  author       = {Evans, Richard and O{\textquoteright}Neill, Michael and Pritzel, Alexander and Antropova, Natasha and Senior, Andrew and Green, Tim and {\v{Z}}{\'\i}dek, Augustin and Bates, Russ and Blackwell, Sam and Yim, Jason and Ronneberger, Olaf and Bodenstein, Sebastian and Zielinski, Michal and Bridgland, Alex and Potapenko, Anna and Cowie, Andrew and Tunyasuvunakool, Kathryn and Jain, Rishub and Clancy, Ellen and Kohli, Pushmeet and Jumper, John and Hassabis, Demis},
  journal      = {bioRxiv},
  title        = {Protein complex prediction with AlphaFold-Multimer},
  year         = {2021},
  elocation-id = {2021.10.04.463034},
  doi          = {10.1101/2021.10.04.463034},
  URL          = {https://www.biorxiv.org/content/early/2021/10/04/2021.10.04.463034},
  eprint       = {https://www.biorxiv.org/content/early/2021/10/04/2021.10.04.463034.full.pdf},
}

Community contributions

Colab notebooks provided by the community (please note that these notebooks may vary from our full AlphaFold system and we did not validate their accuracy):

Acknowledgements

AlphaFold communicates with and/or references the following separate libraries and packages:

Seoklab version makes use of two extra libaries:

We thank all their contributors and maintainers!

Get in Touch

If you have any questions not covered in this overview, please contact the AlphaFold team at [email protected].

We would love to hear your feedback and understand how AlphaFold has been useful in your research. Share your stories with us at [email protected].

License and Disclaimer

This is not an officially supported Google product.

Copyright 2022 DeepMind Technologies Limited.

AlphaFold Code License

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Model Parameters License

The AlphaFold parameters are made available under the terms of the Creative Commons Attribution 4.0 International (CC BY 4.0) license. You can find details at: https://creativecommons.org/licenses/by/4.0/legalcode

Third-party software

Use of the third-party software, libraries or code referred to in the Acknowledgements section above may be governed by separate terms and conditions or license provisions. Your use of the third-party software, libraries or code is subject to any such terms and you should check that you can comply with any applicable restrictions or terms and conditions before use.

Mirrored Databases

The following databases have been mirrored by DeepMind, and are available with reference to the following:

About

A seoklab-flavored version of AlphaFold2.

Resources

Readme

License

Apache-2.0 license
Activity
Custom properties

Stars

0 stars

Watchers

3 watching

Forks

0 forks
Report repository

Releases

9 tags

Packages

No packages published

Languages

  • Python 91.5%
  • Jupyter Notebook 5.3%
  • Shell 2.8%
  • Dockerfile 0.4%