Differences

This shows you the differences between two versions of the page.

--- running_alphafold_at_scale [2026/03/11 10:33] – [Searching the protein sequence databases] 172.20.54.200
+++ running_alphafold_at_scale [2026/03/11 11:51] (current) – 172.20.80.5
@@ Line 60: / Line 60: @@
 === Preparing AlphaFold3 input query files ===
-AlphaFold3 is a little awkward with how it wants it input protein sequences formatted. Instead of a simple FASTA file, it requires a JSON file. Thankfully I found a relatively simple way of converting the FASTA into a JSON file using and editing slightly a python script I found online. It is called ''fasta2alphafoldjson.py'' and it is available on the [[https://github.com/RogerLab/gospel_of_andrew|Gospel of Andrew]] GitHub page. Run it simply as follows:
+AlphaFold3 is a little awkward with how it wants its input protein sequences formatted. Instead of a simple FASTA file, it requires a JSON file. Thankfully I found a relatively simple way of converting the FASTA into a JSON file using and editing slightly a python script I found online. It is called ''fasta2alphafoldjson.py'' and it is available on the [[https://github.com/RogerLab/gospel_of_andrew|Gospel of Andrew]] GitHub page. Run it simply as follows:
 <code>
@@ Line 79: / Line 79: @@
 === Submitting AlphaFold as an array job ===
-If you want to run AlphaFold on many proteins, it may be pragmatic to submit these sequence databases searches as an **array job** on Perun. An array-job is a single job, that in turn schedules the submission of many other jobs. Here the idea is to submit a single general "AlphaFold sequence search job" which then schedules and submits all the individual search jobs for each query protein separately.
+If you want to run AlphaFold on many proteins, it may be pragmatic to submit these sequence database searches as an **array job** on Perun. An array-job is a single job, that in turn schedules the submission of many other jobs. Here the idea is to submit a single general "AlphaFold sequence search job" which then schedules and submits all the individual search jobs for each query protein separately.
 <code>
@@ Line 195: / Line 195: @@
 </code>
-NOTE that this view of the file is truncated with >. The lines are much longer in the actual file. It would be impossible to show the entire file here in the wiki.
+NOTE that this view of the file is truncated with >. The lines are much longer in the actual file. It would be impossible to show the entire file here in the wiki. These files can get quite big. The one I pasted above was 75 MB. I've seen up to 327 MB.
+As you can see it contains the MSA (although I don't yet understand what is meant with paired and unpaired MSA) and a bunch of Templates, which I'm not sure either on what those mean. In any case, it is this JSON file that will be the input for the Structure Module, i.e. the second phase of AlphaFold.
 === AlphaFold uses jackhmmer under the hood ===
@@ Line 210: / Line 212: @@
+=== Running the second phase of AlphaFold, actually predicting the 3D structure ===
+We ran the sequence search phase as an array job, and it was using CPUs, since the task of sequence searching has been optimized for CPUs. However, structure prediction is optimized for using GPUs. We have since recently acquired an NVIDIA GPU and it is now part of Perun as perun24.
+This part thankfully doesn't take as much time, but depending on the number of proteins, it can still take a couple of days. Currently it is pretty stupid, as in, its just doing the structure prediction for each query protein one by one in a for loop. There may be a way to parallalize the workload and thereby make it more time efficient, but I'm not sure yet on how to do that.
+''run_alphafold.py --norun_data_pipeline'' takes in the directory that contains the sequence search result JSON as input.
+<code>
+#!/bin/bash
+#$ -S /bin/bash
+#$ -cwd
+#$ -q GPU@perun24
+# setting up environment
+# first ensure that we are using the right python installation for run_alphafold.py
+# this is needed to make the 'source activate' below work
+export PATH=/scratch5/software/miniconda3/bin:$PATH
+# then append path to include the run_alphafold.py script
+# NOTE: run_alphafold.py was edited slightly to include the #!/usr/bin/env python shebang at the top
+export PATH=/scratch5/software/alphafold3:$PATH
+# activate environment
+source activate alphafold3
+# dir with all the sequence databases
+DB_DIR='/scratch5/software/alphafold3/public_databases'
+# where to find the model parameter file
+MODEL_DIR='/scratch5/db/alphafold3-model'
+SEQ_OUTPUT_DIR='batch_sequence_search_out/'
+# structure inference output directory
+STRUC_OUTPUT_DIR='structure_module_out'
+# do structure inference with GPU
+for QUERY in $SEQ_OUTPUT_DIR/*; do
+    run_alphafold.py \
+        --db_dir $DB_DIR \
+        --model_dir $MODEL_DIR \
+        --input_dir=$QUERY \
+        --output_dir=$STRUC_OUTPUT_DIR \
+        --norun_data_pipeline
+done
+</code>
+Simply submit the script with ''qsub run_alphafold_gpu.sh''. It will generate under ''$STRUC_OUTPUT_DIR'' an output directory for each query protein. That directory will contain many files and subdirectories, but the main file we're after is called ''pyv62_000500_model.cif''. This is your final predicted structure!
+=== Evaluating the final output ===
+== [ID]_model.cif ==
+CIF stands for Crystallographic Information File
+You can view the structures using softwares like PyMOL and ChimeraX
+== [ID]_summary_confidences.json ==
+Contains information regarding the expected overall accuracy of the predicted structure:
+The **ptm** or predicted Template Modeling score
+  * Between 0 and 1, with 1 being the perfect score.
+  * This is a measure of accuracy of the entire structure
+The **iptm** or interface pTM score.
+  * Also between 0 and 1. Null, if a monomer.
+  * This is a measure of confidence in all predicted interfaces between subunits in the multimer, or measure of accuracy of relative positions of subunits to one another
+**fraction disordered**
+  * Also between 0 and 1.
+  * What fraction of the structure is disordered?
+**has_clash**
+  * True or False
+  * True if >50% of atoms of a chain "clash"
+**ranking_score**
+  * Ranges from -100 to 1.5 ?
+  * Calculated as follows: 0.8 * ipTM + 2 * pTM + 0.5 * disorder - 100 * has_clash
+  * This calculation is then used to rank the multiple structure predictions
+There are more metrics to discuss, but I don't have the time right now to continue on them