Mercurial > repos > galaxy-australia > alphafold2

comparison docker/alphafold/README.md @ 1:6c92e000d684 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload for repository https://github.com/usegalaxy-au/galaxy-local-tools commit a510e97ebd604a5e30b1f16e5031f62074f23e86"
author galaxy-australia
date Tue, 01 Mar 2022 02:53:05 +0000
parents
children
comparison
equal deleted inserted replaced
0:7ae9d78b06f5 1:6c92e000d684
1 ![header](imgs/header.jpg)
2
3 # AlphaFold
4
5 This package provides an implementation of the inference pipeline of AlphaFold
6 v2.0. This is a completely new model that was entered in CASP14 and published in
7 Nature. For simplicity, we refer to this model as AlphaFold throughout the rest
8 of this document.
9
10 We also provide an implementation of AlphaFold-Multimer. This represents a work
11 in progress and AlphaFold-Multimer isn't expected to be as stable as our monomer
12 AlphaFold system.
13 [Read the guide](#updating-existing-alphafold-installation-to-include-alphafold-multimers)
14 for how to upgrade and update code.
15
16 Any publication that discloses findings arising from using this source code or the model parameters should [cite](#citing-this-work) the
17 [AlphaFold paper](https://doi.org/10.1038/s41586-021-03819-2) and, if
18 applicable, the [AlphaFold-Multimer paper](https://www.biorxiv.org/content/10.1101/2021.10.04.463034v1).
19
20 Please also refer to the
21 [Supplementary Information](https://static-content.springer.com/esm/art%3A10.1038%2Fs41586-021-03819-2/MediaObjects/41586_2021_3819_MOESM1_ESM.pdf)
22 for a detailed description of the method.
23
24 **You can use a slightly simplified version of AlphaFold with
25 [this Colab
26 notebook](https://colab.research.google.com/github/deepmind/alphafold/blob/main/notebooks/AlphaFold.ipynb)**
27 or community-supported versions (see below).
28
29 ![CASP14 predictions](imgs/casp14_predictions.gif)
30
31 ## First time setup
32
33 The following steps are required in order to run AlphaFold:
34
35 1. Install [Docker](https://www.docker.com/).
36 * Install
37 [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
38 for GPU support.
39 * Setup running
40 [Docker as a non-root user](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user).
41 1. Download genetic databases (see below).
42 1. Download model parameters (see below).
43 1. Check that AlphaFold will be able to use a GPU by running:
44
45 ```bash
46 docker run --rm --gpus all nvidia/cuda:11.0-base nvidia-smi
47 ```
48
49 The output of this command should show a list of your GPUs. If it doesn't,
50 check if you followed all steps correctly when setting up the
51 [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
52 or take a look at the following
53 [NVIDIA Docker issue](https://github.com/NVIDIA/nvidia-docker/issues/1447#issuecomment-801479573).
54
55 If you wish to run AlphaFold using Singularity (a common containerization platform on HPC systems) we recommend using some of the
56 third party Singularity setups as linked in
57 https://github.com/deepmind/alphafold/issues/10 or
58 https://github.com/deepmind/alphafold/issues/24.
59
60 ### Genetic databases
61
62 This step requires `aria2c` to be installed on your machine.
63
64 AlphaFold needs multiple genetic (sequence) databases to run:
65
66 * [BFD](https://bfd.mmseqs.com/),
67 * [MGnify](https://www.ebi.ac.uk/metagenomics/),
68 * [PDB70](http://wwwuser.gwdg.de/~compbiol/data/hhsuite/databases/hhsuite_dbs/),
69 * [PDB](https://www.rcsb.org/) (structures in the mmCIF format),
70 * [PDB seqres](https://www.rcsb.org/) – only for AlphaFold-Multimer,
71 * [Uniclust30](https://uniclust.mmseqs.com/),
72 * [UniProt](https://www.uniprot.org/uniprot/) – only for AlphaFold-Multimer,
73 * [UniRef90](https://www.uniprot.org/help/uniref).
74
75 We provide a script `scripts/download_all_data.sh` that can be used to download
76 and set up all of these databases:
77
78 * Default:
79
80 ```bash
81 scripts/download_all_data.sh <DOWNLOAD_DIR>
82 ```
83
84 will download the full databases.
85
86 * With `reduced_dbs`:
87
88 ```bash
89 scripts/download_all_data.sh <DOWNLOAD_DIR> reduced_dbs
90 ```
91
92 will download a reduced version of the databases to be used with the
93 `reduced_dbs` database preset.
94
95 :ledger: **Note: The download directory `<DOWNLOAD_DIR>` should _not_ be a
96 subdirectory in the AlphaFold repository directory.** If it is, the Docker build
97 will be slow as the large databases will be copied during the image creation.
98
99 We don't provide exactly the database versions used in CASP14 – see the [note on
100 reproducibility](#note-on-reproducibility). Some of the databases are mirrored
101 for speed, see [mirrored databases](#mirrored-databases).
102
103 :ledger: **Note: The total download size for the full databases is around 415 GB
104 and the total size when unzipped is 2.2 TB. Please make sure you have a large
105 enough hard drive space, bandwidth and time to download. We recommend using an
106 SSD for better genetic search performance.**
107
108 The `download_all_data.sh` script will also download the model parameter files.
109 Once the script has finished, you should have the following directory structure:
110
111 ```
112 $DOWNLOAD_DIR/ # Total: ~ 2.2 TB (download: 438 GB)
113 bfd/ # ~ 1.7 TB (download: 271.6 GB)
114 # 6 files.
115 mgnify/ # ~ 64 GB (download: 32.9 GB)
116 mgy_clusters_2018_12.fa
117 params/ # ~ 3.5 GB (download: 3.5 GB)
118 # 5 CASP14 models,
119 # 5 pTM models,
120 # 5 AlphaFold-Multimer models,
121 # LICENSE,
122 # = 16 files.
123 pdb70/ # ~ 56 GB (download: 19.5 GB)
124 # 9 files.
125 pdb_mmcif/ # ~ 206 GB (download: 46 GB)
126 mmcif_files/
127 # About 180,000 .cif files.
128 obsolete.dat
129 pdb_seqres/ # ~ 0.2 GB (download: 0.2 GB)
130 pdb_seqres.txt
131 small_bfd/ # ~ 17 GB (download: 9.6 GB)
132 bfd-first_non_consensus_sequences.fasta
133 uniclust30/ # ~ 86 GB (download: 24.9 GB)
134 uniclust30_2018_08/
135 # 13 files.
136 uniprot/ # ~ 98.3 GB (download: 49 GB)
137 uniprot.fasta
138 uniref90/ # ~ 58 GB (download: 29.7 GB)
139 uniref90.fasta
140 ```
141
142 `bfd/` is only downloaded if you download the full databases, and `small_bfd/`
143 is only downloaded if you download the reduced databases.
144
145 ### Model parameters
146
147 While the AlphaFold code is licensed under the Apache 2.0 License, the AlphaFold
148 parameters are made available for non-commercial use only under the terms of the
149 CC BY-NC 4.0 license. Please see the [Disclaimer](#license-and-disclaimer) below
150 for more detail.
151
152 The AlphaFold parameters are available from
153 https://storage.googleapis.com/alphafold/alphafold_params_2021-10-27.tar, and
154 are downloaded as part of the `scripts/download_all_data.sh` script. This script
155 will download parameters for:
156
157 * 5 models which were used during CASP14, and were extensively validated for
158 structure prediction quality (see Jumper et al. 2021, Suppl. Methods 1.12
159 for details).
160 * 5 pTM models, which were fine-tuned to produce pTM (predicted TM-score) and
161 (PAE) predicted aligned error values alongside their structure predictions
162 (see Jumper et al. 2021, Suppl. Methods 1.9.7 for details).
163 * 5 AlphaFold-Multimer models that produce pTM and PAE values alongside their
164 structure predictions.
165
166 ### Updating existing AlphaFold installation to include AlphaFold-Multimers
167
168 If you have AlphaFold v2.0.0 or v2.0.1 you can either reinstall AlphaFold fully
169 from scratch (remove everything and run the setup from scratch) or you can do an
170 incremental update that will be significantly faster but will require a bit more
171 work. Make sure you follow these steps in the exact order they are listed below:
172
173 1. **Update the code.**
174 * Go to the directory with the cloned AlphaFold repository and run
175 `git fetch origin main` to get all code updates.
176 1. **Download the UniProt and PDB seqres databases.**
177 * Run `scripts/download_uniprot.sh <DOWNLOAD_DIR>`.
178 * Remove `<DOWNLOAD_DIR>/pdb_mmcif`. It is needed to have PDB SeqRes and
179 PDB from exactly the same date. Failure to do this step will result in
180 potential errors when searching for templates when running
181 AlphaFold-Multimer.
182 * Run `scripts/download_pdb_mmcif.sh <DOWNLOAD_DIR>`.
183 * Run `scripts/download_pdb_seqres.sh <DOWNLOAD_DIR>`.
184 1. **Update the model parameters.**
185 * Remove the old model parameters in `<DOWNLOAD_DIR>/params`.
186 * Download new model parameters using
187 `scripts/download_alphafold_params.sh <DOWNLOAD_DIR>`.
188 1. **Follow [Running AlphaFold](#running-alphafold).**
189
190 #### API changes between v2.0.0 and v2.1.0
191
192 We tried to keep the API as much backwards compatible as possible, but we had to
193 change the following:
194
195 * The `RunModel.predict()` now needs a `random_seed` argument as MSA sampling
196 happens inside the Multimer model.
197 * The `preset` flag in `run_alphafold.py` and `run_docker.py` was split into
198 `db_preset` and `model_preset`.
199 * The models to use are not specified using `model_names` but rather using the
200 `model_preset` flag. If you want to customize which models are used for each
201 preset, you will have to modify the the `MODEL_PRESETS` dictionary in
202 `alphafold/model/config.py`.
203 * Setting the `data_dir` flag is now needed when using `run_docker.py`.
204
205
206 ## Running AlphaFold
207
208 **The simplest way to run AlphaFold is using the provided Docker script.** This
209 was tested on Google Cloud with a machine using the `nvidia-gpu-cloud-image`
210 with 12 vCPUs, 85 GB of RAM, a 100 GB boot disk, the databases on an additional
211 3 TB disk, and an A100 GPU.
212
213 1. Clone this repository and `cd` into it.
214
215 ```bash
216 git clone https://github.com/deepmind/alphafold.git
217 ```
218
219 1. Build the Docker image:
220
221 ```bash
222 docker build -f docker/Dockerfile -t alphafold .
223 ```
224
225 1. Install the `run_docker.py` dependencies. Note: You may optionally wish to
226 create a
227 [Python Virtual Environment](https://docs.python.org/3/tutorial/venv.html)
228 to prevent conflicts with your system's Python environment.
229
230 ```bash
231 pip3 install -r docker/requirements.txt
232 ```
233
234 1. Run `run_docker.py` pointing to a FASTA file containing the protein
235 sequence(s) for which you wish to predict the structure. If you are
236 predicting the structure of a protein that is already in PDB and you wish to
237 avoid using it as a template, then `max_template_date` must be set to be
238 before the release date of the structure. You must also provide the path to
239 the directory containing the downloaded databases. For example, for the
240 T1050 CASP14 target:
241
242 ```bash
243 python3 docker/run_docker.py \
244 --fasta_paths=T1050.fasta \
245 --max_template_date=2020-05-14 \
246 --data_dir=$DOWNLOAD_DIR
247 ```
248
249 By default, Alphafold will attempt to use all visible GPU devices. To use a
250 subset, specify a comma-separated list of GPU UUID(s) or index(es) using the
251 `--gpu_devices` flag. See
252 [GPU enumeration](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/user-guide.html#gpu-enumeration)
253 for more details.
254
255 1. You can control which AlphaFold model to run by adding the
256 `--model_preset=` flag. We provide the following models:
257
258 * **monomer**: This is the original model used at CASP14 with no ensembling.
259
260 * **monomer\_casp14**: This is the original model used at CASP14 with
261 `num_ensemble=8`, matching our CASP14 configuration. This is largely
262 provided for reproducibility as it is 8x more computationally
263 expensive for limited accuracy gain (+0.1 average GDT gain on CASP14
264 domains).
265
266 * **monomer\_ptm**: This is the original CASP14 model fine tuned with the
267 pTM head, providing a pairwise confidence measure. It is slightly less
268 accurate than the normal monomer model.
269
270 * **multimer**: This is the [AlphaFold-Multimer](#citing-this-work) model.
271 To use this model, provide a multi-sequence FASTA file. In addition, the
272 UniProt database should have been downloaded.
273
274 1. You can control MSA speed/quality tradeoff by adding
275 `--db_preset=reduced_dbs` or `--db_preset=full_dbs` to the run command. We
276 provide the following presets:
277
278 * **reduced\_dbs**: This preset is optimized for speed and lower hardware
279 requirements. It runs with a reduced version of the BFD database.
280 It requires 8 CPU cores (vCPUs), 8 GB of RAM, and 600 GB of disk space.
281
282 * **full\_dbs**: This runs with all genetic databases used at CASP14.
283
284 Running the command above with the `monomer` model preset and the
285 `reduced_dbs` data preset would look like this:
286
287 ```bash
288 python3 docker/run_docker.py \
289 --fasta_paths=T1050.fasta \
290 --max_template_date=2020-05-14 \
291 --model_preset=monomer \
292 --db_preset=reduced_dbs \
293 --data_dir=$DOWNLOAD_DIR
294 ```
295
296 ### Running AlphaFold-Multimer
297
298 All steps are the same as when running the monomer system, but you will have to
299
300 * provide an input fasta with multiple sequences,
301 * set `--model_preset=multimer`,
302 * optionally set the `--is_prokaryote_list` flag with booleans that determine
303 whether all input sequences in the given fasta file are prokaryotic. If that
304 is not the case or the origin is unknown, set to `false` for that fasta.
305
306 An example that folds a protein complex `multimer.fasta` that is prokaryotic:
307
308 ```bash
309 python3 docker/run_docker.py \
310 --fasta_paths=multimer.fasta \
311 --is_prokaryote_list=true \
312 --max_template_date=2020-05-14 \
313 --model_preset=multimer \
314 --data_dir=$DOWNLOAD_DIR
315 ```
316
317 ### Examples
318
319 Below are examples on how to use AlphaFold in different scenarios.
320
321 #### Folding a monomer
322
323 Say we have a monomer with the sequence `<SEQUENCE>`. The input fasta should be:
324
325 ```fasta
326 >sequence_name
327 <SEQUENCE>
328 ```
329
330 Then run the following command:
331
332 ```bash
333 python3 docker/run_docker.py \
334 --fasta_paths=monomer.fasta \
335 --max_template_date=2021-11-01 \
336 --model_preset=monomer \
337 --data_dir=$DOWNLOAD_DIR
338 ```
339
340 #### Folding a homomer
341
342 Say we have a homomer from a prokaryote with 3 copies of the same sequence
343 `<SEQUENCE>`. The input fasta should be:
344
345 ```fasta
346 >sequence_1
347 <SEQUENCE>
348 >sequence_2
349 <SEQUENCE>
350 >sequence_3
351 <SEQUENCE>
352 ```
353
354 Then run the following command:
355
356 ```bash
357 python3 docker/run_docker.py \
358 --fasta_paths=homomer.fasta \
359 --is_prokaryote_list=true \
360 --max_template_date=2021-11-01 \
361 --model_preset=multimer \
362 --data_dir=$DOWNLOAD_DIR
363 ```
364
365 #### Folding a heteromer
366
367 Say we have a heteromer A2B3 of unknown origin, i.e. with 2 copies of
368 `<SEQUENCE A>` and 3 copies of `<SEQUENCE B>`. The input fasta should be:
369
370 ```fasta
371 >sequence_1
372 <SEQUENCE A>
373 >sequence_2
374 <SEQUENCE A>
375 >sequence_3
376 <SEQUENCE B>
377 >sequence_4
378 <SEQUENCE B>
379 >sequence_5
380 <SEQUENCE B>
381 ```
382
383 Then run the following command:
384
385 ```bash
386 python3 docker/run_docker.py \
387 --fasta_paths=heteromer.fasta \
388 --is_prokaryote_list=false \
389 --max_template_date=2021-11-01 \
390 --model_preset=multimer \
391 --data_dir=$DOWNLOAD_DIR
392 ```
393
394 #### Folding multiple monomers one after another
395
396 Say we have a two monomers, `monomer1.fasta` and `monomer2.fasta`.
397
398 We can fold both sequentially by using the following command:
399
400 ```bash
401 python3 docker/run_docker.py \
402 --fasta_paths=monomer1.fasta,monomer2.fasta \
403 --max_template_date=2021-11-01 \
404 --model_preset=monomer \
405 --data_dir=$DOWNLOAD_DIR
406 ```
407
408 #### Folding multiple multimers one after another
409
410 Say we have a two multimers, `multimer1.fasta` and `multimer2.fasta`. Both are
411 from a prokaryotic organism.
412
413 We can fold both sequentially by using the following command:
414
415 ```bash
416 python3 docker/run_docker.py \
417 --fasta_paths=multimer1.fasta,multimer2.fasta \
418 --is_prokaryote_list=true,true \
419 --max_template_date=2021-11-01 \
420 --model_preset=multimer \
421 --data_dir=$DOWNLOAD_DIR
422 ```
423
424 ### AlphaFold output
425
426 The outputs will be saved in a subdirectory of the directory provided via the
427 `--output_dir` flag of `run_docker.py` (defaults to `/tmp/alphafold/`). The
428 outputs include the computed MSAs, unrelaxed structures, relaxed structures,
429 ranked structures, raw model outputs, prediction metadata, and section timings.
430 The `--output_dir` directory will have the following structure:
431
432 ```
433 <target_name>/
434 features.pkl
435 ranked_{0,1,2,3,4}.pdb
436 ranking_debug.json
437 relaxed_model_{1,2,3,4,5}.pdb
438 result_model_{1,2,3,4,5}.pkl
439 timings.json
440 unrelaxed_model_{1,2,3,4,5}.pdb
441 msas/
442 bfd_uniclust_hits.a3m
443 mgnify_hits.sto
444 uniref90_hits.sto
445 ```
446
447 The contents of each output file are as follows:
448
449 * `features.pkl` – A `pickle` file containing the input feature NumPy arrays
450 used by the models to produce the structures.
451 * `unrelaxed_model_*.pdb` – A PDB format text file containing the predicted
452 structure, exactly as outputted by the model.
453 * `relaxed_model_*.pdb` – A PDB format text file containing the predicted
454 structure, after performing an Amber relaxation procedure on the unrelaxed
455 structure prediction (see Jumper et al. 2021, Suppl. Methods 1.8.6 for
456 details).
457 * `ranked_*.pdb` – A PDB format text file containing the relaxed predicted
458 structures, after reordering by model confidence. Here `ranked_0.pdb` should
459 contain the prediction with the highest confidence, and `ranked_4.pdb` the
460 prediction with the lowest confidence. To rank model confidence, we use
461 predicted LDDT (pLDDT) scores (see Jumper et al. 2021, Suppl. Methods 1.9.6
462 for details).
463 * `ranking_debug.json` – A JSON format text file containing the pLDDT values
464 used to perform the model ranking, and a mapping back to the original model
465 names.
466 * `timings.json` – A JSON format text file containing the times taken to run
467 each section of the AlphaFold pipeline.
468 * `msas/` - A directory containing the files describing the various genetic
469 tool hits that were used to construct the input MSA.
470 * `result_model_*.pkl` – A `pickle` file containing a nested dictionary of the
471 various NumPy arrays directly produced by the model. In addition to the
472 output of the structure module, this includes auxiliary outputs such as:
473
474 * Distograms (`distogram/logits` contains a NumPy array of shape [N_res,
475 N_res, N_bins] and `distogram/bin_edges` contains the definition of the
476 bins).
477 * Per-residue pLDDT scores (`plddt` contains a NumPy array of shape
478 [N_res] with the range of possible values from `0` to `100`, where `100`
479 means most confident). This can serve to identify sequence regions
480 predicted with high confidence or as an overall per-target confidence
481 score when averaged across residues.
482 * Present only if using pTM models: predicted TM-score (`ptm` field
483 contains a scalar). As a predictor of a global superposition metric,
484 this score is designed to also assess whether the model is confident in
485 the overall domain packing.
486 * Present only if using pTM models: predicted pairwise aligned errors
487 (`predicted_aligned_error` contains a NumPy array of shape [N_res,
488 N_res] with the range of possible values from `0` to
489 `max_predicted_aligned_error`, where `0` means most confident). This can
490 serve for a visualisation of domain packing confidence within the
491 structure.
492
493 The pLDDT confidence measure is stored in the B-factor field of the output PDB
494 files (although unlike a B-factor, higher pLDDT is better, so care must be taken
495 when using for tasks such as molecular replacement).
496
497 This code has been tested to match mean top-1 accuracy on a CASP14 test set with
498 pLDDT ranking over 5 model predictions (some CASP targets were run with earlier
499 versions of AlphaFold and some had manual interventions; see our forthcoming
500 publication for details). Some targets such as T1064 may also have high
501 individual run variance over random seeds.
502
503 ## Inferencing many proteins
504
505 The provided inference script is optimized for predicting the structure of a
506 single protein, and it will compile the neural network to be specialized to
507 exactly the size of the sequence, MSA, and templates. For large proteins, the
508 compile time is a negligible fraction of the runtime, but it may become more
509 significant for small proteins or if the multi-sequence alignments are already
510 precomputed. In the bulk inference case, it may make sense to use our
511 `make_fixed_size` function to pad the inputs to a uniform size, thereby reducing
512 the number of compilations required.
513
514 We do not provide a bulk inference script, but it should be straightforward to
515 develop on top of the `RunModel.predict` method with a parallel system for
516 precomputing multi-sequence alignments. Alternatively, this script can be run
517 repeatedly with only moderate overhead.
518
519 ## Note on CASP14 reproducibility
520
521 AlphaFold's output for a small number of proteins has high inter-run variance,
522 and may be affected by changes in the input data. The CASP14 target T1064 is a
523 notable example; the large number of SARS-CoV-2-related sequences recently
524 deposited changes its MSA significantly. This variability is somewhat mitigated
525 by the model selection process; running 5 models and taking the most confident.
526
527 To reproduce the results of our CASP14 system as closely as possible you must
528 use the same database versions we used in CASP. These may not match the default
529 versions downloaded by our scripts.
530
531 For genetics:
532
533 * UniRef90:
534 [v2020_01](https://ftp.uniprot.org/pub/databases/uniprot/previous_releases/release-2020_01/uniref/)
535 * MGnify:
536 [v2018_12](http://ftp.ebi.ac.uk/pub/databases/metagenomics/peptide_database/2018_12/)
537 * Uniclust30: [v2018_08](http://wwwuser.gwdg.de/~compbiol/uniclust/2018_08/)
538 * BFD: [only version available](https://bfd.mmseqs.com/)
539
540 For templates:
541
542 * PDB: (downloaded 2020-05-14)
543 * PDB70: [2020-05-13](http://wwwuser.gwdg.de/~compbiol/data/hhsuite/databases/hhsuite_dbs/old-releases/pdb70_from_mmcif_200513.tar.gz)
544
545 An alternative for templates is to use the latest PDB and PDB70, but pass the
546 flag `--max_template_date=2020-05-14`, which restricts templates only to
547 structures that were available at the start of CASP14.
548
549 ## Citing this work
550
551 If you use the code or data in this package, please cite:
552
553 ```bibtex
554 @Article{AlphaFold2021,
555 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},
556 journal = {Nature},
557 title = {Highly accurate protein structure prediction with {AlphaFold}},
558 year = {2021},
559 volume = {596},
560 number = {7873},
561 pages = {583--589},
562 doi = {10.1038/s41586-021-03819-2}
563 }
564 ```
565
566 In addition, if you use the AlphaFold-Multimer mode, please cite:
567
568 ```bibtex
569 @article {AlphaFold-Multimer2021,
570 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},
571 journal = {bioRxiv}
572 title = {Protein complex prediction with AlphaFold-Multimer},
573 year = {2021},
574 elocation-id = {2021.10.04.463034},
575 doi = {10.1101/2021.10.04.463034},
576 URL = {https://www.biorxiv.org/content/early/2021/10/04/2021.10.04.463034},
577 eprint = {https://www.biorxiv.org/content/early/2021/10/04/2021.10.04.463034.full.pdf},
578 }
579 ```
580
581 ## Community contributions
582
583 Colab notebooks provided by the community (please note that these notebooks may
584 vary from our full AlphaFold system and we did not validate their accuracy):
585
586 * The [ColabFold AlphaFold2 notebook](https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/AlphaFold2.ipynb)
587 by Martin Steinegger, Sergey Ovchinnikov and Milot Mirdita, which uses an
588 API hosted at the Södinglab based on the MMseqs2 server [(Mirdita et al.
589 2019, Bioinformatics)](https://academic.oup.com/bioinformatics/article/35/16/2856/5280135)
590 for the multiple sequence alignment creation.
591
592 ## Acknowledgements
593
594 AlphaFold communicates with and/or references the following separate libraries
595 and packages:
596
597 * [Abseil](https://github.com/abseil/abseil-py)
598 * [Biopython](https://biopython.org)
599 * [Chex](https://github.com/deepmind/chex)
600 * [Colab](https://research.google.com/colaboratory/)
601 * [Docker](https://www.docker.com)
602 * [HH Suite](https://github.com/soedinglab/hh-suite)
603 * [HMMER Suite](http://eddylab.org/software/hmmer)
604 * [Haiku](https://github.com/deepmind/dm-haiku)
605 * [Immutabledict](https://github.com/corenting/immutabledict)
606 * [JAX](https://github.com/google/jax/)
607 * [Kalign](https://msa.sbc.su.se/cgi-bin/msa.cgi)
608 * [matplotlib](https://matplotlib.org/)
609 * [ML Collections](https://github.com/google/ml_collections)
610 * [NumPy](https://numpy.org)
611 * [OpenMM](https://github.com/openmm/openmm)
612 * [OpenStructure](https://openstructure.org)
613 * [pandas](https://pandas.pydata.org/)
614 * [pymol3d](https://github.com/avirshup/py3dmol)
615 * [SciPy](https://scipy.org)
616 * [Sonnet](https://github.com/deepmind/sonnet)
617 * [TensorFlow](https://github.com/tensorflow/tensorflow)
618 * [Tree](https://github.com/deepmind/tree)
619 * [tqdm](https://github.com/tqdm/tqdm)
620
621 We thank all their contributors and maintainers!
622
623 ## License and Disclaimer
624
625 This is not an officially supported Google product.
626
627 Copyright 2021 DeepMind Technologies Limited.
628
629 ### AlphaFold Code License
630
631 Licensed under the Apache License, Version 2.0 (the "License"); you may not use
632 this file except in compliance with the License. You may obtain a copy of the
633 License at https://www.apache.org/licenses/LICENSE-2.0.
634
635 Unless required by applicable law or agreed to in writing, software distributed
636 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
637 CONDITIONS OF ANY KIND, either express or implied. See the License for the
638 specific language governing permissions and limitations under the License.
639
640 ### Model Parameters License
641
642 The AlphaFold parameters are made available for non-commercial use only, under
643 the terms of the Creative Commons Attribution-NonCommercial 4.0 International
644 (CC BY-NC 4.0) license. You can find details at:
645 https://creativecommons.org/licenses/by-nc/4.0/legalcode
646
647 ### Third-party software
648
649 Use of the third-party software, libraries or code referred to in the
650 [Acknowledgements](#acknowledgements) section above may be governed by separate
651 terms and conditions or license provisions. Your use of the third-party
652 software, libraries or code is subject to any such terms and you should check
653 that you can comply with any applicable restrictions or terms and conditions
654 before use.
655
656 ### Mirrored Databases
657
658 The following databases have been mirrored by DeepMind, and are available with reference to the following:
659
660 * [BFD](https://bfd.mmseqs.com/) (unmodified), by Steinegger M. and Söding J., available under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
661
662 * [BFD](https://bfd.mmseqs.com/) (modified), by Steinegger M. and Söding J., modified by DeepMind, available under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/). See the Methods section of the [AlphaFold proteome paper](https://www.nature.com/articles/s41586-021-03828-1) for details.
663
664 * [Uniclust30: v2018_08](http://wwwuser.gwdg.de/~compbiol/uniclust/2018_08/) (unmodified), by Mirdita M. et al., available under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
665
666 * [MGnify: v2018_12](http://ftp.ebi.ac.uk/pub/databases/metagenomics/peptide_database/current_release/README.txt) (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](https://creativecommons.org/publicdomain/zero/1.0/).