AlphaFold3-Sapelo2 - Revision history

Jordan: /* Running Program */

2026-08-07T20:58:19Z

Running Program

← Older revision		Revision as of 16:58, 7 August 2026
Line 83:		Line 83:
	Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
	* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.		* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
	* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory: for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the containers for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB; <b>also, be aware that v3.0.4 introduced several updated dependencies and appears to use significantly more memory than previous versions for the same inputs.</b>		* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory: for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the containers for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB, and memory usage scales not only with input size but also number of sample and diffusion iterations; <b>also, be aware that v3.0.4 introduced several updated dependencies and appears to use significantly more memory than previous versions for the same inputs.</b>
	* While the above values are the default maximums, it's possible to adjust them at runtime: if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").		* While the above values are the default maximums, it's possible to adjust them at runtime: if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").
	* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).		* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).

Jordan: /* Running Program */

2026-08-07T20:17:50Z

Running Program

← Older revision		Revision as of 16:17, 7 August 2026
Line 83:		Line 83:
	Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
	* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.		* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
	* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the containers for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.		* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory: for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the containers for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB; <b>also, be aware that v3.0.4 introduced several updated dependencies and appears to use significantly more memory than previous versions for the same inputs.</b>
	* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").		* While the above values are the default maximums, it's possible to adjust them at runtime: if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").
	* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).		* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).

Jordan: /* Running Program */

2026-08-07T20:15:33Z

Running Program

← Older revision		Revision as of 16:15, 7 August 2026
Line 83:		Line 83:
	Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
	* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.		* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
	* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the ~~contains~~ for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.		* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the containers for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.
	* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").		* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").
	* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).		* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).

Jordan: /* Version */

2026-08-07T20:14:16Z

Version

← Older revision		Revision as of 16:14, 7 August 2026
Line 8:		Line 8:

	== Version ==		== Version ==
	3.0.0, 3.0.1, 3.0.2, 3.0.3		3.0.0, 3.0.1, 3.0.2, 3.0.3, 3.0.4

	== Author / Distributor ==		== Author / Distributor ==

Jordan: /* Running Program */

2026-08-07T20:07:25Z

Running Program

← Older revision		Revision as of 16:07, 7 August 2026
Line 79:		Line 79:
	singularity exec /apps/singularity-images/alphafold-3.0.4.sif python /app/alphafold/run_alphafold.py --helpfull		singularity exec /apps/singularity-images/alphafold-3.0.4.sif python /app/alphafold/run_alphafold.py --helpfull
	</pre>		</pre>
			</br>
			</br>
	Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
	* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.		* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
Line 85:		Line 86:
	* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").		* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").
	* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).		* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).
	~~</br>~~
	</br>		</br>
	Note that AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; as of 08/06/2026, this is now available centrally at /db/AlphaFold3/model_parameters/20260604/af3.bin. Both the databases and the model parameters file must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).		Note that AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; as of 08/06/2026, this is now available centrally at /db/AlphaFold3/model_parameters/20260604/af3.bin. Both the databases and the model parameters file must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).

Jordan: /* Running Program */

2026-08-07T20:06:44Z

Running Program

← Older revision		Revision as of 16:06, 7 August 2026
Line 80:		Line 80:
	</pre>		</pre>

	Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory per GPU device), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
	* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.		* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
	* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the contains for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.		* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the contains for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.

Jordan: /* Running Program */

2026-08-07T20:04:28Z

Running Program

← Older revision		Revision as of 16:04, 7 August 2026
Line 68:		Line 68:
	singularity exec /apps/singularity-images/alphafold-3.0.3.sif python /app/alphafold/run_alphafold.py --helpfull		singularity exec /apps/singularity-images/alphafold-3.0.3.sif python /app/alphafold/run_alphafold.py --helpfull
	</pre>		</pre>
	~~Note that AlphaFold~~ 3 is GPU dependent while also being CPU and memory intensive, meaning that it will only run on the A100 and H100 nodes and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). ~~<b>Furthemore, the "unifiedmem" and "JSON-~~4" versions have unified memory enabled, which allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are large enough to exceed the standard maximum of 5,120 tokens; not only does this substantially increase run times, it will also <i>only</i> work on the A100 nodes due to architectural conflicts with the H100 nodes. To use either of these versions with a large protein or other complex, please use the following Slurm header in your submission script in place of the corresponding "--gres" header seen in the sample job below (and note that you can remove the "#SBATCH --constraint" header for this):~~</b>~~
			*'''Version 3.0.4'''

			This version is installed as a singularity container:
	<pre class="gscript">		<pre class="gscript">
	...		/apps/singularity-images/alphafold-3.0.4.sif
	~~#SBATCH~~ --~~gres=gpu:A100:1~~		</pre>
	...		You can view the documentation for this version of AlphaFold with the following command, in an interactive job (i.e., NOT a login/submit node, where Singularity does not work):
			<pre class="gcommand">
			singularity exec /apps/singularity-images/alphafold-3.0.4.sif python /app/alphafold/run_alphafold.py --helpfull
	</pre>		</pre>

	~~Please~~ also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless~~. While~~ tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).		Note that AlphaFold 3 is GPU dependent while also being CPU intensive unless you elect to provide your own multiple sequence alignments (MSAs) produced in a separate step beforehand. This means that, for most proteins, it will only run on the A100 and H100 nodes (it has been tested on the L4 nodes but only for fairly small proteins like the example input below) and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). For especially large inputs (i.e., complexes that exceed the "standard" maximum of 5,120 tokens on the A100 and H100 nodes, all of which have 80GB of device memory), unified memory has been enabled by default starting with alphafold-3.0.1-unifiedmem.sif and all subsequent versions. Unified memory allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are larger than can be handled with the available device memory alone; however, there are some caveats and considerations:
			* For one, use of this "extra" memory is <b>extremely</b> slow, often increasing run times from several minutes to several hours; although this mode now works on both H100 and A100 nodes, H100 nodes seem to run faster in this mode than A100 nodes.
			* For another, host memory is the memory you request in your Slurm headers with "#SBATCH --mem=" so you need to make sure you're accounting for this when submitting a job for a large complex that's likely to need unified memory; for all unified memory-enabled containers for v3.0.1 and v3.0.2, the default is 3.2 times the amount of device memory per GPU, so 3.2 x 80GB = 256GB, while the contains for v3.0.3 and v3.0.4 have a default of 4.0 times the device memory, or 4.0 x 80GB = 320GB.
			* While the above values are the default maximums, it's possible to adjust them at runtime; if you attempt to model a large complex and receive a "RESOURCE EXHAUSTED" error but <i>not</i> an "OOM killed" error, you can manually increase the amount of host memory that gets allocated to your AlphaFold command using the "--env XLA_CLIENT_MEM_FRACTION=X.Y" flag after the "--nv" flag (see example command below), where "X" and "Y" are integer values (e.g., "--env XLA_CLIENT_MEM_FRACTION=<b>5.0</b>").
			* Finally, please also note that like many AI tools, AlphaFold is prone to "hallucinations" when dealing with inputs that are too large; this mostly manifests as results with polypeptides predicted to occupy the same 3D space, which obviously makes these results useless; while tests with a complex of up to ~9,700 tokens (the urease complex from <i>Helicobacter pylori</i>) completed successfully, to date, the largest complex observed to run <b>correctly</b> was ~7,300 tokens (the ornithine decarboxylase, specifically <i>SpeF</i>, complex from <i>Salmonella</i>).
	</br>		</br>
	</br>		</br>
	AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; as of 08/06/2026, ~~these are~~ now available centrally at /db/AlphaFold3/model_parameters/20260604/af3.bin. Both the databases and the model parameters file must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).		Note that AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; as of 08/06/2026, this is now available centrally at /db/AlphaFold3/model_parameters/20260604/af3.bin. Both the databases and the model parameters file must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).

	Sample job submission script to run the singularity container for v3.0.0 on a GPU:		Sample job submission script to run the singularity container for v3.0.0 on a GPU:

Jordan: /* Running Program */

2026-08-06T17:14:32Z

Running Program

← Older revision		Revision as of 13:14, 6 August 2026
Line 101:		Line 101:
	--bind /Path/to/input/file:/root/af_input \		--bind /Path/to/input/file:/root/af_input \
	--bind /Path/to/output_directory:/root/af_output \		--bind /Path/to/output_directory:/root/af_output \
	--bind /~~Path~~/to/model_parameters:/root/models \		--bind /db/AlphaFold3/model_parameters/20260604:/root/models \
	--bind /db/AlphaFold3/20241114:/root/public_databases \		--bind /db/AlphaFold3/20241114:/root/public_databases \
	/apps/singularity-images/alphafold-3.0.1-JSON-4.sif \		/apps/singularity-images/alphafold-3.0.1-JSON-4.sif \

Jordan: /* Running Program */

2026-08-06T17:12:47Z

Running Program

@@ Line 32: / Line 32: @@
 </pre>
-'''Version 3.0.1'''
+*'''Version 3.0.1'''
 This version is installed as a singularity container:
@@ Line 45: / Line 45: @@
 <pre class="gcommand">
 singularity exec /apps/singularity-images/alphafold-3.0.1.sif python /app/alphafold/run_alphafold.py --helpfull
 </pre>
 Note that AlphaFold 3 is GPU dependent while also being CPU and memory intensive, meaning that it will only run on the A100 and H100 nodes and needs numerous CPUs to run in a timely/efficient manner (see the example job submission script below). <b>Furthemore, the "unifiedmem" and "JSON-4" versions have unified memory enabled, which allows the GPU device to "borrow" host memory from the node for proteins and other complexes that are large enough to exceed the standard maximum of 5,120 tokens; not only does this substantially increase run times, it will also <i>only</i> work on the A100 nodes due to architectural conflicts with the H100 nodes. To use either of these versions with a large protein or other complex, please use the following Slurm header in your submission script in place of the corresponding "--gres" header seen in the sample job below (and note that you can remove the "#SBATCH --constraint" header for this):</b>
@@ Line 56: / Line 78: @@
 </br>
 </br>
-AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; currently this is only available directly from Google, and can be obtained by completing the form found here: https://docs.google.com/forms/d/e/1FAIpQLSfWZAgo1aYk0O4MuAXZj8xRQ8DafeFJnldNOnh_13qAx2ceZw/viewform. Once these are obtained and placed somewhere in your storage space on Sapelo2 (/home or /work is recommended), they must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).
+AlphaFold 3 also depends on a set of database files, the current versions of which can be found at /db/AlphaFold3/20241114, and a file containing the model parameters; as of 08/06/2026, these are now available centrally at /db/AlphaFold3/model_parameters/20260604/af3.bin. Both the databases and the model parameters file must be included with the '-B' or "--bind" option at runtime, as must the location of the input file and output directory (see example below).
 Sample job submission script to run the singularity container for v3.0.0 on a GPU:

Jordan: /* Version */

2026-07-28T18:14:50Z

Version

← Older revision		Revision as of 14:14, 28 July 2026
Line 8:		Line 8:

	== Version ==		== Version ==
	3.0.0, 3.0.1		3.0.0, 3.0.1, 3.0.2, 3.0.3

	== Author / Distributor ==		== Author / Distributor ==