View source for AlphaFold2

__NOTOC__
{{back_to_tutorials}}

[https://deepmind.com/research/case-studies/alphafold AlphaFold2] predicts a protein's 3D folding structure by its amino acid sequence with [https://deepmind.com/blog/article/alphafold-a-solution-to-a-50-year-old-grand-challenge-in-biology the accuracy that is competitive with experimental results]. [https://github.com/deepmind/alphafold The AlphaFold package] is now installed in the new software stack on Euler.

== Load modules ==
The AlphaFold module can be loaded as following.
 $ env2lmod
 $ module load gcc/6.3.0 openmpi/4.0.2 alphafold/2.1.1
 Now run 'alphafold_init' to initialize the virtual environment
 
 The following have been reloaded with a version change:
   1) gcc/4.8.5 => gcc/6.3.0
 
 $ alphafold_init
 (venv_alphafold) [jarunanp@eu-login-18 ~]$ 

== Databases ==
The AlphaFold databases has the total size when unzipped of 2.2 TB. Users can download the databases to $SCRATCH. However, if there are several users of AlphaFold in your group, institute or department, we recommend to use a group storage.

For D-BIOL members, the AlphaFold databases are currently located at /cluster/work/biol/alphafold.

== Download the AlphaFold databases to your $SCRATCH ==
* Download and install aria2c in your $HOME
 $ cd $HOME
 $ wget https://github.com/aria2/aria2/releases/download/release-1.36.0/aria2-1.36.0.tar.gz
 $ tar xvzf aria2-1.36.0.tar.gz
 $ cd aria2-1.36.0
 $ module load gcc/6.3.0 gnutls/3.5.13 openssl/1.0.1e
 $ ./configure --prefix=$HOME/.local
 $ make
 $ make install
 $ export PATH="$HOME/.local/bin:$PATH"
 $ which aria2c
 ~/.local/bin/aria2c

* Check if you have enough space in your $SCRATCH. You may need to free up your $SCRATCH in case there is not enough space.
 $ lquota
 +-----------------------------+-------------+------------------+------------------+------------------+
 | Storage location:           | Quota type: | Used:            | Soft quota:      | Hard quota:      |
 +-----------------------------+-------------+------------------+------------------+------------------+
 | /cluster/home/jarunanp      | space       |         10.38 GB |         17.18 GB |         21.47 GB |
 | /cluster/home/jarunanp      | files       |            85658 |           160000 |           200000 |
 +-----------------------------+-------------+------------------+------------------+------------------+
 | /cluster/shadow             | space       |         16.38 kB |          2.15 GB |          2.15 GB |
 | /cluster/shadow             | files       |                7 |            50000 |            50000 |
 +-----------------------------+-------------+------------------+------------------+------------------+
 | /cluster/scratch/jarunanp   | space       |          2.42 TB |          2.50 TB |          2.70 TB |
 | /cluster/scratch/jarunanp   | files       |           201844 |          1000000 |          1500000 |
 +-----------------------------+-------------+------------------+------------------+------------------+

* Create a folder for the databases
 $ cd $SCRATCH
 $ mkdir alphafold_databases

* Download the databases: you can call a script to download all the databases or call a script for each databases. These scripts are in the same directory $ALPHAFOLD_ROOT/scripts/. 

 $ bsub -W 24:00 "$ALPHAFOLD_ROOT/scripts/download_all_data.sh $SCRATCH/alphafold_databases"

== Submit a job ==
Here is an example of a job submission script (job_script.bsub) which requests 12 CPU cores, in total 120GB of memory, in total 120GB of local scratch space and one GPU.

 #!/usr/bin/bash
 #BSUB -n 12
 #BSUB -W 4:00
 #BSUB -R "rusage[mem=10000, scratch=10000, ngpus_excl_p=1]"
 #BSUB -J alphafold
 
 source /cluster/apps/local/env2lmod.sh
 module load gcc/6.3.0 openmpi/4.0.2 alphafold/2.1.1
 source /cluster/apps/nss/alphafold/venv_alphafold/bin/activate
 
 # Define paths to databases
 DATA_DIR="/cluster/scratch/jarunanp/21_10_alphafold_databases"
 
 python /cluster/apps/nss/alphafold/alphafold-2.1.1/run_alphafold.py \
 --data_dir=$DATA_DIR \
 --output_dir=$TMPDIR \
 --max_template_date="2021-12-06" \
 --bfd_database_path=$DATA_DIR/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt \
 --uniref90_database_path=$DATA_DIR/uniref90/uniref90.fasta \
 --uniclust30_database_path=$DATA_DIR/uniclust30/uniclust30_2018_08/uniclust30_2018_08 \
 --mgnify_database_path=$DATA_DIR/mgnify/mgy_clusters_2018_12.fa \
 --pdb70_database_path=$DATA_DIR/pdb70/pdb70 \
 --template_mmcif_dir=$DATA_DIR/pdb_mmcif/mmcif_files \
 --obsolete_pdbs_path=$DATA_DIR/pdb_mmcif/obsolete.dat \
 --fasta_paths=ubiquitin.fasta
 
 # Copy the results from the compute node
 mkdir -p output
 cp -r $TMPDIR/* output

Submit a job with the command
 $ bsub < job_script.sh

The screen output is saved in the output file named starting with ''lsf.o'' followed by the JobID, e.g., lsf.o195525946. Please see [[Job output|this page]] for how to read the output file.

From testing folding [https://www.ebi.ac.uk/pdbe/entry/pdb/3h7p/protein/1 ubiquitin.fasta] with AlphaFold, it took around 40 minutes to finish for the databases stored on $SCRATCH.

== Benchmark results ==
AlphaFold2 uses HHsearch and HHblits from the HH-suite to perform protein sequence searching. The HH-suite searches do many random file access and read operations. Therefore, it is recommended to store the databases of AlphaFold on a solid state drive (SSD) due to the significantly higher input/output speed (IOPS) compared to a traditional mechanical hard disk drive (HDD). 

We tested the performance of AlphaFold to fold two proteins ([https://www.ebi.ac.uk/pdbe/entry/pdb/3h7p/protein/1 ubiquitin.fasta with the length of 76 amino acids], [https://www.predictioncenter.org/casp14/target.cgi?target=T1050 T1050.fasta with the length of 779 amino acids]) reading the AlphaFold databases from our three central storage systems.
* '''/cluster/scratch''' is a fast, short-term, personal storage system based on SSD
* '''/cluster/project''' is a long-term group storage system which uses HDD for the permanent storage and NVMe flash caches to accelerate the reading speed
* '''/cluster/work''' is a fast, long-term, group storage system based on HDD and suitable for large files

The tests ran on four of NVIDIA GPU models available on Euler including RTX 2080 Ti, TITAN RTX, GTX 1080 Ti and GTX 1080 ([[GPU_job_submission#Available_GPU_node_types|see the GPU specs here]]). All jobs allocated 12 CPU cores, 1 GPU, the total memory of 120 GB and the total scratch space of 120 GB. The figures below show the benchmark results which are the average runtime of five runs for the tests with the databases on /cluster/scratch and /cluster/project. The tests with the databases on /cluster/work were run only once because the small reads on this storage system decrease significantly not only the performance of these particular tests but also the overall performance of the whole /cluster/work storage system. The tested compute nodes were not reserved for testing, i.e., the compute nodes might be loaded by other computational while the AlphaFold tests were running. 

<table>
<tr>
<td>
[[Image:Benchmark ubiquitin 1gpu.jpg|600px]]

<small>Fig 1: The performance results of AlphFold2 in folding the Ubiquitin structure  </small>
</td>
<td>
[[Image:Benchmark T1050 1gpu.jpg|600px]]

<small>Fig 2: The performance results of AlphFold2 in folding the T1050 structure  </small>
</td>
</tr>
</table>

<table>
<tr>
<td style="width: 600px; text-align:left">
[[Image:Alphafold ubiquitin.png|500px]]
</td>
<td style="width: 600px; text-align:left">
[[Image:Alphafold_T1050.png|400px]]
</td>
</tr>
</table>
<table>
<tr style="vertical-align:top;">
<td style="width: 550px; text-align:left: ">
<small>Fig 3: This figure shows a cartoon representation of two superimposed ubiquitin structures. Ubiquitin is a small monomeric protein with 78 amino acids. The structure in blue has been determined experimentally (X-ray crystallography, pdb database code: 1upq.pdb). The model in green shows the structure predicted by AlphaFold2. The RMSD (root mean square distance) between the two structures is 0.797 A. The RMSD has been calculated for the backbone atoms. (Image and caption text by Dr. Simon Rüdisser, BNSP)</small>
</td>
<td style="width: 50px;">
</td>
<td style="width: 550px; text-align:left">
<small>Fig 4: The five models of T1050 generated by AlphaFold2 are shown as cartoon representation. T1050 is a monomeric protein with 780 amino acids. T1050 is one of the targets from the CASP (Critical Assessment of Techniques for Protein Structure Prediction) initiative. (Image and caption text by Dr. Simon Rüdisser, BNSP) </small>
</td>
</tr>
</table>
 
From testing folding the two proteins with AlphaFold, '''/cluster/project shows to be the best choice as a group storage for the AlphaFold databases.''' The performance of AlphaFold when reading the data from /cluster/scratch and /cluster/project is comparable to one another and around 10 times faster than when reading the data from /cluster/work. /cluster/scratch is for short-term storage and only for personal use and, therefore, it is not an optimal solution for a group of users. Comparing GPU models, RTX 1080 Ti and TITAN RTX show better performance than GTX 1080 Ti and GTX 1080. The performance of AlphaFold is also affected by the network latency while running on the latter two GPUs which are located in Zurich and not together with the storage systems in Lugano.

== Further readings ==
* [https://deepmind.com/blog/article/alphafold-a-solution-to-a-50-year-old-grand-challenge-in-biology DeepMind Blog post: "AlphaFold: a solution to a 50-year-old grand challenge in biology"]
[https://ethz.ch/en/news-and-events/eth-news/news/2021/08/computer-algorithms-revolutionise-biology.html ETH News: "Computer algorithms are currently revolutionising biology"]
{{back_to_tutorials}}