alphafold Documentation

Technical Documentation: google-deepmind/alphafold

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`) Copy Section

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
community-supported versions (see below).

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

Installation and running your first prediction Copy Chapter

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. Install Docker.

   • Install
     NVIDIA Container Toolkit
     for GPU support.
   • Setup running
     Docker as a non-root user.

2. Clone this repository and cd into it.

   bash Copy

   git clone https://github.com/deepmind/alphafold.git
   cd ./alphafold

3. 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).
     Same for rsync.

   • 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:

   bash Copy

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

   • Note: The download directory <DOWNLOAD_DIR> should not be a
     subdirectory in the AlphaFold repository directory. If it is, the
     Docker build will be slow as the large databases will be copied into the
     docker build context.

   • It is possible to run AlphaFold with reduced databases; please refer to
     the complete documentation.

4. Check that AlphaFold will be able to use a GPU by running:

   bash Copy

   docker run --rm --gpus all nvidia/cuda:11.0-base nvidia-smi

   The output of this command should show a list of your GPUs. If it doesn't,
   check if you followed all steps correctly when setting up the
   NVIDIA Container Toolkit
   or take a look at the following
   NVIDIA Docker issue.

   If you wish to run AlphaFold using Singularity (a common containerization
   platform on HPC systems) we recommend using some of the third party
   Singularity setups as linked in
   https://github.com/deepmind/alphafold/issues/10 or
   https://github.com/deepmind/alphafold/issues/24.

5. Build the Docker image:

   bash Copy

   docker build -f docker/Dockerfile -t alphafold .

   If you encounter the following error:

   text Copy

   W: GPG error: https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY A4B469963BF863CC
   E: The repository 'https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease' is not signed.

   use the workaround described in
   https://github.com/deepmind/alphafold/issues/463#issuecomment-1124881779.

6. Install the run_docker.py dependencies. Note: You may optionally wish to
   create a
   Python Virtual Environment
   to prevent conflicts with your system's Python environment.

   bash Copy

   pip3 install -r docker/requirements.txt

7. Make sure that the output directory exists (the default is /tmp/alphafold)
   and that you have sufficient permissions to write into it.

8. Run run_docker.py pointing to a FASTA file containing the protein
   sequence(s) for which you wish to predict the structure (--fasta_paths
   parameter). AlphaFold will search for the available templates before the
   date specified by the --max_template_date parameter; this could be used to
   avoid certain templates during modeling. --data_dir is the directory with
   downloaded genetic databases and --output_dir is the absolute path to the
   output directory.

   bash Copy

   python3 docker/run_docker.py \
     --fasta_paths=your_protein.fasta \
     --max_template_date=2022-01-01 \
     --data_dir=$DOWNLOAD_DIR \
     --output_dir=/home/user/absolute_path_to_the_output_dir

9. 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 Copy Section

This step requires aria2c to be installed on your machine.

AlphaFold needs multiple genetic (sequence) databases to run:

• BFD,
• MGnify,
• PDB70,
• PDB (structures in the mmCIF format),
• PDB seqres – only for AlphaFold-Multimer,
• UniRef30 (FKA UniClust30),
• UniProt – only for AlphaFold-Multimer,
• UniRef90.

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

• Recommended default:

  bash Copy

  scripts/download_all_data.sh <DOWNLOAD_DIR>

  will download the full databases.

• With reduced_dbs parameter:

  bash Copy

  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).

:ledger: Note: The download directory <DOWNLOAD_DIR> should not be a
subdirectory in the AlphaFold repository directory. If it is, the Docker build
will be slow as the large databases will be copied during the image creation.

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.

:ledger: 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.

:ledger: 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 Copy Section

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 Copy Section

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 Copy Chapter

The simplest way to run AlphaFold is using the provided Docker script. This
was tested on Google Cloud with a machine using the nvidia-gpu-cloud-image
with 12 vCPUs, 85 GB of RAM, a 100 GB boot disk, the databases on an additional
3 TB disk, and an A100 GPU. For your first run, please follow the instructions
from
Installation and running your first prediction
section.

1. By default, Alphafold will attempt to use all visible GPU devices. To use a
   subset, specify a comma-separated list of GPU UUID(s) or index(es) using the
   --gpu_devices flag. See
   GPU enumeration
   for more details.

2. You can control which AlphaFold model to run by adding the --model_preset=
   flag. We provide the following models:

   • monomer: This is the original model used at CASP14 with no
     ensembling.

   • monomer_casp14: This is the original model used at CASP14 with
     num_ensemble=8, matching our CASP14 configuration. This is largely
     provided for reproducibility as it is 8x more computationally expensive
     for limited accuracy gain (+0.1 average GDT gain on CASP14 domains).

   • monomer_ptm: This is the original CASP14 model fine tuned with the
     pTM head, providing a pairwise confidence measure. It is slightly less
     accurate than the normal monomer model.

   • multimer: This is the AlphaFold-Multimer model.
     To use this model, provide a multi-sequence FASTA file. In addition, the
     UniProt database should have been downloaded.

3. You can control MSA speed/quality tradeoff by adding
   --db_preset=reduced_dbs or --db_preset=full_dbs to the run command. We
   provide the following presets:

   • reduced_dbs: This preset is optimized for speed and lower hardware
     requirements. It runs with a reduced version of the BFD database. It
     requires 8 CPU cores (vCPUs), 8 GB of RAM, and 600 GB of disk space.

   • full_dbs: This runs with all genetic databases used at CASP14.

   Running the command above with the monomer model preset and the
   reduced_dbs data preset would look like this:

   bash Copy

   python3 docker/run_docker.py \
     --fasta_paths=T1050.fasta \
     --max_template_date=2020-05-14 \
     --model_preset=monomer \
     --db_preset=reduced_dbs \
     --data_dir=$DOWNLOAD_DIR \
     --output_dir=/home/user/absolute_path_to_the_output_dir

4. 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.

5. 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.

6. AlphaFold can reuse 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 Copy Section

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_preset=multimer,

An example that folds a protein complex multimer.fasta:

python3 docker/run_docker.py \
  --fasta_paths=multimer.fasta \
  --max_template_date=2020-05-14 \
  --model_preset=multimer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

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 Copy Section

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.

Examples Copy Section

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:

python3 docker/run_docker.py \
  --fasta_paths=monomer.fasta \
  --max_template_date=2021-11-01 \
  --model_preset=monomer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

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:

python3 docker/run_docker.py \
  --fasta_paths=homomer.fasta \
  --max_template_date=2021-11-01 \
  --model_preset=multimer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

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:

python3 docker/run_docker.py \
  --fasta_paths=heteromer.fasta \
  --max_template_date=2021-11-01 \
  --model_preset=multimer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

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:

python3 docker/run_docker.py \
  --fasta_paths=monomer1.fasta,monomer2.fasta \
  --max_template_date=2021-11-01 \
  --model_preset=monomer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

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:

python3 docker/run_docker.py \
  --fasta_paths=multimer1.fasta,multimer2.fasta \
  --max_template_date=2021-11-01 \
  --model_preset=multimer \
  --data_dir=$DOWNLOAD_DIR \
  --output_dir=/home/user/absolute_path_to_the_output_dir

AlphaFold output Copy Section

The outputs will be saved in a subdirectory of the directory provided via the
--output_dir flag of run_docker.py (defaults to /tmp/alphafold/). The
outputs include the computed MSAs, unrelaxed structures, relaxed structures,
ranked structures, raw model outputs, prediction metadata, and section timings.
The --output_dir 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/
        bfd_uniref_hits.a3m
        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 Copy Chapter

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 Copy Chapter

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:

• UniRef90:
  v2020_01
• MGnify:
  v2018_12
• Uniclust30: v2018_08
• BFD: only version available

For templates:

• PDB: (downloaded 2020-05-14)
• PDB70:
  2020-05-13

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 Copy Chapter

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 Copy Chapter

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):

• The
  ColabFold AlphaFold2 notebook
  by Martin Steinegger, Sergey Ovchinnikov and Milot Mirdita, which uses an
  API hosted at the Södinglab based on the MMseqs2 server
  (Mirdita et al. 2019, Bioinformatics)
  for the multiple sequence alignment creation.

Acknowledgements Copy Chapter

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

• Abseil
• Biopython
• Colab
• Docker
• HH Suite
• HMMER Suite
• Haiku
• JAX
• Kalign
• matplotlib
• ML Collections
• NumPy
• OpenMM
• OpenStructure
• pymol3d
• Sonnet
• TensorFlow
• Tree
• tqdm

We thank all their contributors and maintainers!

Get in Touch Copy Chapter

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 Copy Chapter

This is not an officially supported Google product.

Copyright 2022 DeepMind Technologies Limited.

AlphaFold 2 and its output are for theoretical modeling only. They are not
intended, validated, or approved for clinical use. You should not use the
AlphaFold 2 or its output for clinical purposes or rely on them for medical or
other professional advice. Any content regarding those topics is provided for
informational purposes only and is not a substitute for advice from a qualified
professional.

Output of AlphaFold 2 are predictions with varying levels of confidence and
should be interpreted carefully. Use discretion before relying on, publishing,
downloading or otherwise using AlphaFold 2 and its output.

AlphaFold Code License Copy Section

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 Copy Section

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 Copy Section

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 Copy Section

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

• BFD (unmodified), by Steinegger M. and Söding J.,
  available under a
  Creative Commons Attribution-ShareAlike 4.0 International License.

• BFD (modified), by Steinegger M. and Söding J.,
  modified by DeepMind, available under a
  Creative Commons Attribution-ShareAlike 4.0 International License.
  See the Methods section of the
  AlphaFold proteome paper
  for details.

• Uniref30: v2021_03
  (unmodified), by Mirdita M. et al., available under a
  Creative Commons Attribution-ShareAlike 4.0 International License.

• MGnify: v2022_05
  (unmodified), by Mitchell AL et al., available free of all copyright
  restrictions and made fully and freely available for both non-commercial and
  commercial use under
  CC0 1.0 Universal (CC0 1.0) Public Domain Dedication.

Overview (`afdb/README.md`) Copy Section

AlphaFold Protein Structure Database

Introduction Copy Chapter

The AlphaFold UniProt release (214M predictions) is hosted on
Google Cloud Public Datasets,
and is available to download at no cost under a
CC-BY-4.0 licence. The
dataset is in a Cloud Storage bucket, and metadata is available on BigQuery. A
Google Cloud account is required for the download, but the data can be freely
used under the terms of the
CC-BY 4.0 Licence.

This document provides an overview of how to access and download the dataset for
different use cases. Please refer to the
AlphaFold database FAQ for further information
on what proteins are in the database and a changelog of releases.

:ledger: Note: The full dataset is difficult to manipulate without significant
computational resources (the size of the dataset is 23 TiB, 3 * 214M files).

There are also alternatives to downloading the full dataset:

1. Download a premade subset (covering important species / Swiss-Prot) via our
   download page.
2. Download a custom subset of the data. See below.

If you need to download the full dataset then please see the "Bulk download"
section. See "Creating a Google Cloud Account" below for more information on how
to avoid any surprise costs when using Google Cloud Public Datasets.

Licence Copy Chapter

Data is available for academic and commercial use, under a
CC-BY-4.0 licence.

EMBL-EBI expects attribution (e.g. in publications, services or products) for
any of its online services, databases or software in accordance with good
scientific practice.

If you make use of an AlphaFold prediction, please cite the following papers:

• Jumper, J et al. Highly accurate protein structure prediction with
  AlphaFold. Nature
  (2021).
• Varadi, M et al. AlphaFold Protein Structure Database: massively expanding
  the structural coverage of protein-sequence space with high-accuracy models.
  Nucleic Acids Research
  (2021).

AlphaFold Data Copyright (2022) DeepMind Technologies Limited.

Disclaimer Copy Chapter

The AlphaFold Data and other information provided on this site is for
theoretical modelling only, caution should be exercised in its use. It is
provided 'as-is' without any warranty of any kind, whether expressed or implied.
For clarity, no warranty is given that use of the information shall not infringe
the rights of any third party. The information is not intended to be a
substitute for professional medical advice, diagnosis, or treatment, and does
not constitute medical or other professional advice.

Format Copy Chapter

Dataset file names start with a protein identifier of the form AF-[a UniProt accession]-F[a fragment number].

Three files are provided for each entry:

• model_v4.cif – contains the atomic coordinates for the predicted protein
  structure, along with some metadata. Useful references for this file format
  are the ModelCIF and
  PDBx/mmCIF project sites.
• confidence_v4.json – contains a confidence metric output by AlphaFold
  called pLDDT. This provides a number for each residue, indicating how
  confident AlphaFold is in the local surrounding structure. pLDDT ranges
  from 0 to 100, where 100 is most confident. This is also contained in the
  CIF file.
• predicted_aligned_error_v4.json – contains a confidence metric output by
  AlphaFold called PAE. This provides a number for every pair of residues,
  which is lower when AlphaFold is more confident in the relative position of
  the two residues. PAE is more suitable than pLDDT for judging confidence in
  relative domain placements.
  See here for a description of the
  format.

Predictions grouped by NCBI taxonomy ID are available as
proteomes/proteome-tax_id-[TAX ID]-[SHARD ID]_v4.tar within the same bucket.

There are also two extra files stored in the bucket:

• accession_ids.csv – This file contains a list of all the UniProt
  accessions that have predictions in AlphaFold DB. The file is in CSV format
  and includes the following columns, separated by a comma:
  • UniProt accession, e.g. A8H2R3
  • First residue index (UniProt numbering), e.g. 1
  • Last residue index (UniProt numbering), e.g. 199
  • AlphaFold DB identifier, e.g. AF-A8H2R3-F1
  • Latest version, e.g. 4
• sequences.fasta – This file contains sequences for all proteins in the
  current database version in FASTA format. The identifier rows start with
  ">AFDB", followed by the AlphaFold DB identifier and the name of the
  protein. The sequence rows contain the corresponding amino acid sequences.
  Each sequence is on a single line, i.e. there is no wrapping.

Creating a Google Cloud Account Copy Chapter

Downloading from the Google Cloud Public Datasets (rather than from AFDB or 3D
Beacons) requires a Google Cloud account. See the
Google Cloud get started page, and
explore the free tier account usage limits.

IMPORTANT: After the trial period has finished (90 days), to continue access,
you are required to upgrade to a billing account. While your free tier access
(including access to the Public Datasets storage bucket) continues, usage beyond
the free tier will incur costs – please familiarise yourself with the pricing
for the services that you use to avoid any surprises.

1. Go to
   https://cloud.google.com/datasets.
2. Create an account:
   1. Click "get started for free" in the top right corner.
   2. Agree to all terms of service.
   3. Follow the setup instructions. Note that a payment method is required,
      but this will not be used unless you enable billing.
   4. Access to the Google Cloud Public Datasets storage bucket is always at
      no cost and you will have access to the
      free tier.
3. Set up a project:
   1. In the top left corner, click the navigation menu (three horizontal bars
      icon).
   2. Select: "Cloud overview" -> "Dashboard".
   3. In the top left corner there is a project menu bar (likely says "My
      First Project"). Select this and a "Select a Project" box will appear.
   4. To keep using this project, click "Cancel" at the bottom of the box.
   5. To create a new project, click "New Project" at the top of the box:
      1. Select a project name.
      2. For location, if your organization has a Cloud account then select
         this, otherwise leave as is.
4. Install the Google Cloud CLI to download the data from Google Cloud Storage:
   1. Follow these
      instructions.

Accessing the dataset Copy Chapter

The data is available from:

• GCS data bucket:
  gs://public-datasets-deepmind-alphafold-v4

Bulk download Copy Chapter

We don't recommend downloading the full dataset unless required for processing
with local computational resources, for example in an academic high performance
computing centre.

We estimate that a 1 Gbps internet connection will allow download of the full
database in roughly 2.5 days.

While we don’t know the exact nature of your computational infrastructure, below
are some suggested approaches for downloading the dataset. Please reach out to
[email protected] if you have any
questions.

The recommended way of downloading the whole database is by downloading
1,015,797 sharded proteome tar files using the command below. This is
significantly faster than downloading all of the individual files because of
large constant per-file latency.

gcloud storage cp --recursive gs://public-datasets-deepmind-alphafold-v4/proteomes/ .

You will then have to un-tar all of the proteomes and un-gzip all of the
individual files. Note that after un-taring, there will be about 644M files, so
make sure your filesystem can handle this.

Storage Transfer Service Copy Section

Some users might find the
Storage Transfer Service a
convenient way to set up the transfer between this bucket and another bucket, or
another cloud service. Using this service may incur costs. Please check the
pricing page for more
detail, particularly for transfers to other cloud services.

Downloading subsets of the data Copy Chapter

AlphaFold Database search Copy Section

For simple queries, for example by protein name, gene name or UniProt accession
you can use the main search bar on
alphafold.ebi.ac.uk.

3D Beacons Copy Section

3D-Beacons is an international collaboration of
protein structure data providers to create a federated network with unified data
access mechanisms. The 3D-Beacons platform allows users to retrieve coordinate
files and metadata of experimentally determined and theoretical protein models
from data providers such as AlphaFold DB.

More information about how to access AlphaFold predictions using 3D-Beacons is
available at
3D-Beacons documentation.

Other premade species subsets Copy Section

Downloads for some model organism proteomes, global health proteomes and
Swiss-Prot are available on the
AFDB website. These are generated from
reference proteomes. If you
want other species, or all proteins for a particular species, please continue
reading.

We provide 1,015,797 sharded tar files for all species in
gs://public-datasets-deepmind-alphafold-v4/proteomes/.
We shard each proteome so that each shard contains at most 10,000 proteins
(which corresponds to 30,000 files per shard, since there are 3 files per
protein). To download a proteome of your choice, you have to do the following
steps:

1. Find the NCBI taxonomy ID
   ([TAX_ID]) of the species in question.
2. Run gcloud storage cp gs://public-datasets-deepmind-alphafold-v4/proteomes/proteome-tax_id-[TAX ID]-*_v4.tar . to download all shards for this proteome.
3. Un-tar all of the downloaded files and un-gzip all of the individual files.

File manifests Copy Section

Pre-made lists of files (manifests) are available at
gs://public-datasets-deepmind-alphafold-v4/manifests.
Note that these filenames do not include the bucket prefix, but this can be
added once the files have been downloaded to your filesystem.

One can also define their own list of files, for example created by BigQuery
(see below). gcloud storage cp can be used to download these files with

cat [manifest file] | gcloud storage cp --read-paths-from-stdin .

This will be much slower than downloading the tar files (grouped by species)
because each file has an associated overhead.

BigQuery Copy Section

IMPORTANT: The
free tier of Google Cloud
comes with BigQuery Sandbox
with 1 TB of free processed query data each month. Repeated queries within a
month could exceed this limit and if you have
upgraded to a paid Cloud Billing account
you may be charged.

This should be sufficient for running a number of queries on the metadata
table, though the usage depends on the size of the columns queried and selected.
Please look at the
BigQuery pricing page for more
information.

This is the user's responsibility so please ensure you keep track of your
billing settings and resource usage in the console.

BigQuery provides a serverless and highly scalable analytics tool enabling SQL
queries over large datasets. The metadata for the UniProt dataset takes up ​​113
GiB and so can be challenging to process and analyse locally. The table name is:

• BigQuery metadata table:
  bigquery-public-data.deepmind_alphafold.metadata

With BigQuery SQL you can do complex queries, e.g. find all high accuracy
predictions for a particular species, or even join on to other datasets, e.g. to
an experimental dataset by the uniprotSequence, or to the NCBI taxonomy by
taxId.

If you would find additional information in the metadata useful please file a
GitHub issue.

Setup

Follow the
BigQuery Sandbox set up guide.

Exploring the metadata

The column names and associated data types available can be found using the
following query.

SELECT column_name, data_type FROM bigquery-public-data.deepmind_alphafold.INFORMATION_SCHEMA.COLUMNS
WHERE table_name = 'metadata'

Producing summary statistics

The following query gives the mean of the prediction confidence fractions per
species.

SELECT
 organismScientificName AS name,
 SUM(fractionPlddtVeryLow) / COUNT(fractionPlddtVeryLow) AS mean_plddt_very_low,
 SUM(fractionPlddtLow) / COUNT(fractionPlddtLow) AS mean_plddt_low,
 SUM(fractionPlddtConfident) / COUNT(fractionPlddtConfident) AS mean_plddt_confident,
 SUM(fractionPlddtVeryHigh) / COUNT(fractionPlddtVeryHigh) AS mean_plddt_very_high,
 COUNT(organismScientificName) AS num_predictions
FROM bigquery-public-data.deepmind_alphafold.metadata
GROUP by name
ORDER BY num_predictions DESC;

Producing lists of files

We expect that the most important use for the metadata will be to create subsets
of proteins according to various criteria, so that users can choose to only copy
a subset of the 214M proteins that exist in the dataset. An example query is
given below:

with file_rows AS (
  with file_cols AS (
    SELECT
      CONCAT(entryID, '-model_v4.cif') as m,
      CONCAT(entryID, '-predicted_aligned_error_v4.json') as p
    FROM bigquery-public-data.deepmind_alphafold.metadata
    WHERE organismScientificName = "Homo sapiens"
      AND (fractionPlddtVeryHigh + fractionPlddtConfident) > 0.5
  )
  SELECT * FROM file_cols UNPIVOT (files for filetype in (m, p))
)
SELECT CONCAT('gs://public-datasets-deepmind-alphafold-v4/', files) as files
from file_rows

In this case, the list has been filtered to only include proteins from Homo
sapiens for which over half the residues are confident or better (>70 pLDDT).

This creates a table with one column "files", where each row is the cloud
location of one of the two file types that has been provided for each protein.
There is an additional confidence_v4.json file which contains the per-residue
pLDDT. This information is already in the CIF file but may be preferred if only
this information is required.

This allows users to bulk download the exact proteins they need, without having
to download the entire dataset. Other columns may also be used to select subsets
of proteins, and we point the user to the
BigQuery documentation to understand
other ways to filter for their desired protein lists. Likewise, the
documentation should be followed to download these file subsets locally, as the
most appropriate approach will depend on the filesize. Note that it may be
easier to download large files using Colab
(e.g. pandas to_csv).

Previous versions

Previous versions of AFDB will remain available at
gs://public-datasets-deepmind-alphafold
to enable reproducible research. We recommend using the latest version (v4).

Overview (`server/README.md`) Copy Section

JSON file format for AlphaFold Server jobs

You can
download an example JSON file here;
here we describe the contents of this example JSON file.

This JSON file consists of a list of dictionaries (even in the case of a single
dictionary, a single-element list must be used), with each dictionary containing
a job description. Therefore, you can specify multiple jobs in one JSON file.

Each job description contains a job name, a list of PRNG seeds (which can be an
empty list for automated random seed assignment), and a list of entities
(molecules) to be modeled.

AlphaFold Server JSON files are especially useful for automation of repetitive
modeling jobs (e.g. to screen interactions of one protein with a small number of
others). The easiest way to construct an initial JSON file is to run a modeling
job via AlphaFold Server GUI and use it as a template. AlphaFold Server will
produce a zip file containing modeling results. Inside the zip file you will
find a JSON file named <job_name>_job_request.json containing the job inputs.
These files offer a convenient starting point for generating new jobs as they
are easily editable in standard text editors or in programming environments like
Google Colab notebooks.

Note that comments are not allowed in JSON files.

Job name, seeds and sequences Copy Chapter

• name is a string with the job name. This is how the job will appear as in
  the job history table.
• modelSeeds is a list of strings of uint32 seed values (e.g.
  ["1593933729", "4273"]). Seeds are used to run the modeling. We recommend
  providing an empty list, in which case a single random seed will be used.
  This is the recommended option.
• sequences is a list of dictionaries that carry descriptions of the
  entities (molecules) for modeling.

{
  "name": "Test Fold Job Number One",
  "modelSeeds": [],
  "sequences": [...],
  "dialect": "alphafoldserver",
  "version": 1
}

Entity types Copy Chapter

Valid entity types mirror those available in the AlphaFold Server web interface:

• proteinChain – used for proteins
• dnaSequence – used for DNA (single strand)
• rnaSequence – used for RNA (single strand)
• ligand – used for allowed ligands
• ion – used for allowed ions
• dialect – The dialect of the input JSON. It should be set to
  alphafoldserver
• version – The version of the input JSON. It should be set to 1. See
  versions below for more information.

Versions Copy Chapter

The top-level version field (for the alphafoldserver dialect) can be either
undefined or 1. The following features have been added in respective
versions:

• Not set: the initial AlphaFold Server input format.
• 1: added the option of specifying external templates using newly added
  fields maxTemplateDate and useStructureTemplate.

Protein chains Copy Section

sequence is a string containing protein sequence; the same limitations as in
the UI are in place, e.g. only letters corresponding to amino acids are allowed,
as defined by IUPAC. Only 20 standard amino acid type are supported.

count is the number of copies of this protein chain (integer).

glycans is an optional list of dictionaries that carries descriptions of the
protein glycosylation.

• residues is a string defining glycan. Please refer to the
  FAQ for the format description and
  allowed glycans.
• position is a position of the amino acid to which the glycan is attached
  (integer, 1-based indexing).

modifications is an optional list of dictionaries that carries descriptions of
the post-translational modifications.

• ptmType is a string containing the
  CCD code of the modification; the same
  codes are allowed as in the UI.
• position is a position of the modified amino acid (integer).
• Allowed modifications: CCD_SEP, CCD_TPO, CCD_PTR, CCD_NEP,
  CCD_HIP, CCD_ALY, CCD_MLY, CCD_M3L, CCD_MLZ, CCD_2MR, CCD_AGM,
  CCD_MCS, CCD_HYP, CCD_HY3, CCD_LYZ, CCD_AHB, CCD_P1L, CCD_SNN,
  CCD_SNC, CCD_TRF, CCD_KCR, CCD_CIR, CCD_YHA

useStructureTemplate is an optional boolean that determines whether the model
should use PDB templates, with a default value of true.

maxTemplateDate is an optional ISO 8601 date string (YYYY-MM-DD) specifying
the upper date limit for considering PDB templates. Only templates released on
or before this date will be used. The lower bound for the date is 1976-01-01
(which effectively cuts off all templates) and the maximum date one can
currently set is 2025-02-03 (date of last download from PDB used to generate the
templates).

unpairedMsa is an optional string containing a multiple sequence
alignment (MSA) in A3M format. Providing an unpaired MSA allows you to guide
the prediction process, e.g. predict different structural states of the protein
using MSA clustering. Please refer to the
FAQ
for more details on unpaired MSAs and how they are used.

templates is an optional list of dictionaries that allows you to provide
custom structural templates.

• mmcif is a string containing the mmCIF file content for the template.
• queryIndices is a list O-based indices in the query sequence, defining the
  mapping from query residues to template residues.
• templateIndices is a list of O-based indices in the template sequence,
  specifying the mapping from query residues to template residues defined in
  the mmCIF file. Note that unresolved mmCIF residues must be taken into
  account when specifying template indices.

Note: queryIndices and templateIndices are parallel arrays where
queryIndices[i] maps to templateIndices[i].

{
  "proteinChain": {
    "sequence": "PREACHINGS",

    "glycans": [
      {
        "residues": "NAG(NAG)(BMA)",
        "position": 8
      },
      {
        "residues": "BMA",
        "position": 10
      }
    ],

    "modifications": [
      {
        "ptmType": "CCD_HY3",
        "ptmPosition": 1
      },
      {
        "ptmType": "CCD_P1L",
        "ptmPosition": 5
      }
    ],

    "count": 1,
    "maxTemplateDate": "2018-01-20",
    "unpairedMsa": ">query\nPREACHINGS\n>unpaired seq 1\nPREA--INGS",
    "templates": [
      {
        "mmcif": ...,
        "queryIndices": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
        "templateIndices": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      }
    ]
  }
},
{
  "proteinChain": {
    "sequence": "REACHER",
    "count": 1,
    "useStructureTemplate": false
  }
}

DNA chains Copy Section

Please note that the dnaSequence type refers to single stranded DNA. If you
wish to model double stranded DNA, please add a second "dnaSequence", carrying
the sequence of the reverse complement strand.

sequence is a string containing a DNA sequence; the same limitations as in the
UI are in place, i.e. only letters A, T, G, C are allowed.

count is a number of copies of this DNA chain (integer).

modifications is an optional list of dictionaries that carries descriptions of
the DNA chemical modifications.

• modificationType is a string containing
  CCD code of modification; the same codes
  are allowed as in the UI.
• basePosition is a position of the modified nucleotide (integer).
• Allowed modifications: CCD_5CM, CCD_C34, CCD_5HC, CCD_6OG,
  CCD_6MA, CCD_1CC, CCD_8OG, CCD_5FC, CCD_3DR

{
  "dnaSequence": {
    "sequence": "GATTACA",

    "modifications": [
      {
        "modificationType": "CCD_6OG",
        "basePosition": 1
      },
      {
        "modificationType": "CCD_6MA",
        "basePosition": 2
      }
    ],

    "count": 1
  }
},
{
  "dnaSequence": {
    "sequence": "TGTAATC",
    "count": 1
  }
}

RNA chains Copy Section

sequence is a string containing RNA sequence (single strand); the same
limitations as in the UI are in place, e.g. only letters A, U, G, C are allowed.

count is a number of copies of this RNA chain (integer).

modifications is an optional list of dictionaries that carries descriptions of
the RNA chemical modifications.

• modificationType is a string containing
  CCD code of modification; the same codes
  are allowed as in the UI.
• basePosition is a position of the modified nucleotide (integer).
• Allowed modifications: CCD_PSU, CCD_5MC, CCD_OMC, CCD_4OC,
  CCD_5MU, CCD_OMU, CCD_UR3, CCD_A2M, CCD_MA6, CCD_6MZ, CCD_2MG,
  CCD_OMG, CCD_7MG, CCD_RSQ

{
  "rnaSequence": {
    "sequence": "GUAC",

    "modifications": [
      {
        "modificationType": "CCD_2MG",
        "basePosition": 1
      },
      {
        "modificationType": "CCD_5MC",
        "basePosition": 4
      }
    ],

    "count": 1
  }
}

Ligands Copy Section

ligand is a string containing the CCD code
of the ligand; the same codes are allowed as in the UI.

count is the number of copies of this ligand (integer).

Allowed ligands: CCD_ADP, CCD_ATP, CCD_AMP, CCD_GTP, CCD_GDP,
CCD_FAD, CCD_NAD, CCD_NAP, CCD_NDP, CCD_HEM, CCD_HEC, CCD_PLM,
CCD_OLA, CCD_MYR, CCD_CIT, CCD_CLA, CCD_CHL, CCD_BCL, CCD_BCB

{
  "ligand": {
    "ligand": "CCD_ATP",
    "count": 1
  }
},
{
  "ligand": {
    "ligand": "CCD_HEM",
    "count": 2
  }
}

Ions Copy Section

ion is a string containing CCD code of the
ion; the same codes are allowed as in the UI. The ion charge is implicitly
specified by the CCD code.

count is a number of copies of this ion (integer).

Allowed ions: MG, ZN, CL, CA, NA, MN, K, FE, CU, CO

{
  "ion": {
    "ion": "MG",
    "count": 2
  }
},
{
  "ion": {
    "ion": "NA",
    "count": 3
  }
}

Additional modeling jobs

You may specify multiple jobs in one JSON file. This is an example of a simple
job request for one protein chain and two copies of the palindromic DNA
sequence:

{
  "name": "Test Fold Job Number Two",
  "modelSeeds": [],
  "sequences": [
    {
      "proteinChain": {
        "sequence": "TEACHINGS",
        "count": 1
      }
    },
    {
      "dnaSequence": {
        "sequence": "TAGCTA",
        "count": 2
      }
    }
  ],
  "dialect": "alphafoldserver",
  "version": 1
}

Technical Note V2.3.0 (`docs/technical_note_v2.3.0.md`) Copy Section

AlphaFold v2.3.0

Update (2026-03-11): Added note about cluster filtering change.

This technical note describes updates in the code and model weights that were
made to produce AlphaFold v2.3.0 including updated training data.

We have fine-tuned new AlphaFold-Multimer weights using identical model
architecture but a new training cutoff of 2021-09-30. Previously released
versions of AlphaFold and AlphaFold-Multimer were trained using PDB structures
with a release date before 2018-04-30, a cutoff date chosen to coincide with the
start of the 2018 CASP13 assessment. The new training cutoff represents ~30%
more data to train AlphaFold and more importantly includes much more data on
large protein complexes. The new training cutoff includes 4× the number of
electron microscopy structures and in aggregate twice the number of large
structures (more than 2,000 residues)[^1]. Due to the significant increase in
the number of large structures, we are also able to increase the size of
training crops (subsets of the structure used to train AlphaFold) from 384 to
640 residues. These new AlphaFold-Multimer models are expected to be
substantially more accurate on large protein complexes even though we use the
same model architecture and training methodology as our previously released
AlphaFold-Multimer paper.

AlphaFold v2.3.0 training also used a modified self-distillation set compared to
previous AF-Multimer versions. The original AF-Multimer self-distillation set
was created using the clustered MGnify dataset filtered to clusters with more
than 10 sequences. For v2.3.0, the same clustered MGnify dataset was used, but
filtered to clusters with more than 2 sequences.

These models were initially developed in response to a request from the CASP
organizers to better understand baselines for the progress of structure
prediction in CASP15, and because of the significant increase in accuracy for
large targets, we are making them available as the default multimer models.
Since they were developed as baselines, we have emphasized minimal changes to
our previous AlphaFold-Multimer system while accommodating larger complexes.
In particular, we increase the number of chains used at training time from 8 to
20 and increase the maximum number of MSA sequences from 1,152 to 2,048 for 3 of
the 5 AlphaFold-Multimer models.

For the CASP15 baseline, we also used somewhat more expensive inference settings
that have been found externally to improve AlphaFold accuracy. We increase the
number of seeds per model to 20[^2] and increase the maximum number of
recyclings to 20 with early stopping[^3]. Increasing the number of seeds to 20
is recommended for very large or difficult targets but is not the default due to
increased computational time.

Overall, we expect these new models to be the preferred models whenever the
stoichiometry of the complex is known, including known monomeric structures. In
cases where the stoichiometry is unknown, such as in genome-scale prediction, it
is likely that single chain AlphaFold will be more accurate on average unless
the chain has several thousand residues.

The predicted structures used for the CASP15 baselines are available
here.

[^1]: wwPDB Consortium. "Protein Data Bank: the single global archive for 3D
macromolecular structure data." Nucleic Acids Res. 47, D520–D528 (2018).

[^2]: Johansson-Åkhe, Isak, and Björn Wallner. "Improving peptide-protein
docking with AlphaFold-Multimer using forced sampling." Frontiers in
bioinformatics 2 (2022): 959160-959160.

[^3]: Gao, Mu, et al. "AF2Complex predicts direct physical interactions in
multimeric proteins with deep learning." Nature communications 13.1 (2022):
1-13.

--- METRICS ---

• Files Extracted: 4
• Estimated Token Budget: ~17276 tokens
• Canonical Reference: https://codewiki.google/github.com/google-deepmind/alphafold