AlphaFold2 Protein Prediction

Predict protein structures with Nobel Prize-winning AI — powered by GPU acceleration on Clore.ai

AlphaFold2, developed by DeepMind, revolutionized structural biology by predicting protein 3D structures with atomic accuracy. It has been applied to over 200 million protein sequences and earned the 2024 Nobel Prize in Chemistry. Running AlphaFold2 requires significant GPU memory and compute — Clore.ai provides affordable access to the high-end GPUs needed.

GitHub: google-deepmind/alphafold — 13K+ ⭐

---

Prerequisites

• A Clore.ai account with sufficient balance

• Basic familiarity with the Linux command line

• Your target protein sequence(s) in FASTA format

• ~2.5TB disk space for the full genetic databases (or use reduced databases for testing)

---

Why Run AlphaFold2 on Clore.ai?

AlphaFold2 benefits enormously from GPU acceleration:

Hardware	Prediction Time (typical protein ~400aa)
CPU only	6–24+ hours
Single A100 80GB	15–45 minutes
Single RTX 4090	20–60 minutes
Single RTX 3090	30–90 minutes

Clore.ai offers A100, RTX 4090, and RTX 3090 nodes at a fraction of cloud provider costs, making large-scale proteomics studies accessible.

---

Step 1 — Choose Your GPU Rental on Clore.ai

Recommended GPUs for AlphaFold2:

• A100 80GB — Best for large proteins (>700 aa) and multimer prediction

• RTX 4090 24GB — Great for standard monomers (<500 aa)

• RTX 3090 24GB — Cost-effective for smaller proteins

For multimer prediction, 40GB+ VRAM is strongly recommended.

1. Log in to clore.ai and go to Marketplace

2. Filter by GPU model (A100 or RTX 4090 recommended)

3. Ensure the server has at least 100GB disk space (or 2.5TB for full databases)

4. Select a server and click Rent

---

Step 2 — Configure Your Deployment

When setting up your rental order, use the following configuration:

Docker Image:

nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu20.04

AlphaFold2 requires a custom Docker setup. We will install it from source inside the container. Alternatively, use the community image catgumag/alphafold or merteroglu/alphafold2 which pre-packages the environment.

Ports to expose:

22

Environment Variables:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Minimum Resources:

• CPU: 8 cores

• RAM: 32GB (64GB recommended for large proteins)

• Disk: 100GB minimum (2.5TB for full databases)

---

Step 3 — Connect via SSH

Once your instance is running:

ssh root@<server-ip> -p <ssh-port>

Verify GPU is visible:

nvidia-smi

Expected output should show your GPU (e.g., A100 80GB SXM4).

---

Step 4 — Install AlphaFold2

Option A: Using the Official Installer Script

# Update system packages
apt-get update && apt-get install -y \
    wget \
    git \
    python3-pip \
    python3-dev \
    aria2 \
    hmmer \
    kalign \
    hhsuite

# Install Miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh
bash miniconda.sh -b -p /opt/conda
export PATH="/opt/conda/bin:$PATH"

# Clone AlphaFold2
git clone https://github.com/google-deepmind/alphafold.git /opt/alphafold
cd /opt/alphafold

# Create conda environment
conda env create -f environment.yml
conda activate alphafold

Option B: Using pip (Faster Setup)

# Install system dependencies
apt-get update && apt-get install -y \
    wget curl git aria2 hmmer kalign

# Install hhsuite
conda install -c bioconda hhsuite

# Clone and install AlphaFold2
git clone https://github.com/google-deepmind/alphafold.git /opt/alphafold
cd /opt/alphafold

pip install -r requirements.txt
pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

# Install AlphaFold itself
python3 setup.py install

---

Step 5 — Download Genetic Databases

Full database download requires ~2.5TB disk space and can take 6–24 hours. For initial testing, use the reduced databases (see Reduced DB section below).

Full Databases (Production Use)

cd /opt/alphafold

# Download all databases using the provided script
bash scripts/download_all_data.sh /data/alphafold_databases

This downloads:

• BFD (~270GB) — Big Fantastic Database

• UniRef90 (~58GB) — UniProt Reference Clusters

• MGnify (~64GB) — Metagenomics sequences

• PDB70 (~56GB) — Protein Data Bank representative structures

• PDB seqres (~0.2GB)

• UniClust30 (~86GB)

• Small BFD (~17GB) — Reduced version

Reduced Databases (Testing/Development)

For testing on limited disk:

# Download only small_bfd and necessary databases
bash scripts/download_small_bfd.sh /data/alphafold_databases
bash scripts/download_pdb70.sh /data/alphafold_databases
bash scripts/download_uniclust30.sh /data/alphafold_databases
bash scripts/download_uniref90.sh /data/alphafold_databases
bash scripts/download_mgnify.sh /data/alphafold_databases
bash scripts/download_pdb_seqres.sh /data/alphafold_databases
bash scripts/download_uniprot.sh /data/alphafold_databases

---

Step 6 — Download AlphaFold Model Weights

# Create directory for model parameters
mkdir -p /data/alphafold_databases/params

# Download model parameters (~3.5GB)
wget -q -P /data/alphafold_databases/params \
    https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar

# Extract
tar -xf /data/alphafold_databases/params/alphafold_params_2022-12-06.tar \
    -C /data/alphafold_databases/params

---

Step 7 — Prepare Your Input Sequence

Create a FASTA file with your target protein sequence:

cat > /tmp/target_protein.fasta << 'EOF'
>my_protein
MKTLLLTLVVVTIVCLDLGAVGNGSGLKCRQTGSCVHFPKDLQALPKDDTASDLNRSLDAEAFKAFQRLAENFNATEYRDIQNFNNKIQHSLEELAKKLDEKLAKLKEKLKQLEN
EOF

FASTA Format Tips:

• Header line starts with >

• Sequence should contain only standard amino acid letters (ACDEFGHIKLMNPQRSTVWY)

• Remove any gaps or non-standard characters

• For multimer prediction, include all chains with separate headers

---

Step 8 — Run AlphaFold2

Monomer Prediction (Single Chain)

cd /opt/alphafold

python3 run_alphafold.py \
    --fasta_paths=/tmp/target_protein.fasta \
    --max_template_date=2022-01-01 \
    --model_preset=monomer \
    --db_preset=full_dbs \
    --data_dir=/data/alphafold_databases \
    --output_dir=/tmp/alphafold_output \
    --uniref90_database_path=/data/alphafold_databases/uniref90/uniref90.fasta \
    --mgnify_database_path=/data/alphafold_databases/mgnify/mgy_clusters_2022_05.fa \
    --template_mmcif_dir=/data/alphafold_databases/pdb_mmcif/mmcif_files \
    --obsolete_pdbs_path=/data/alphafold_databases/pdb_mmcif/obsolete.dat \
    --pdb70_database_path=/data/alphafold_databases/pdb70/pdb70 \
    --bfd_database_path=/data/alphafold_databases/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt \
    --uniclust30_database_path=/data/alphafold_databases/uniclust30/uniclust30_2018_08/uniclust30_2018_08 \
    --use_gpu_relax=True

Multimer Prediction (Protein Complex)

python3 run_alphafold.py \
    --fasta_paths=/tmp/complex.fasta \
    --max_template_date=2022-01-01 \
    --model_preset=multimer \
    --db_preset=full_dbs \
    --data_dir=/data/alphafold_databases \
    --output_dir=/tmp/alphafold_output \
    --uniref90_database_path=/data/alphafold_databases/uniref90/uniref90.fasta \
    --mgnify_database_path=/data/alphafold_databases/mgnify/mgy_clusters_2022_05.fa \
    --template_mmcif_dir=/data/alphafold_databases/pdb_mmcif/mmcif_files \
    --obsolete_pdbs_path=/data/alphafold_databases/pdb_mmcif/obsolete.dat \
    --uniprot_database_path=/data/alphafold_databases/uniprot/uniprot.fasta \
    --pdb_seqres_database_path=/data/alphafold_databases/pdb_seqres/pdb_seqres.txt \
    --use_gpu_relax=True

---

Step 9 — Understanding Output Files

AlphaFold2 produces several output files per prediction:

/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Best predicted structure
├── ranked_1.pdb          # Second-best prediction
├── ranked_2.pdb
├── ranked_3.pdb
├── ranked_4.pdb
├── result_model_1.pkl    # Full prediction data (pickle)
├── result_model_2.pkl
├── ...
├── msas/                 # Multiple Sequence Alignments
│   ├── bfd_uniclust_hits.a3m
│   ├── mgnify_hits.sto
│   └── uniref90_hits.sto
└── timings.json          # Runtime breakdown

Interpreting Results:

• ranked_0.pdb is your best structure — open it in PyMOL, ChimeraX, or UCSF Chimera

• pLDDT score (0–100): per-residue confidence. >90 = very high, 70–90 = good, 50–70 = low, <50 = disordered

• PAE (Predicted Aligned Error) plots show inter-domain confidence

---

Step 10 — Visualize Results

Download PDB Files to Your Local Machine

# From your local machine:
scp -P <ssh-port> root@<server-ip>:/tmp/alphafold_output/my_protein/ranked_0.pdb ./

# Or use rsync for the full output directory:
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/tmp/alphafold_output/ \
    ./alphafold_results/

Visualize in PyMOL (locally)

# In PyMOL:
load ranked_0.pdb
spectrum b, blue_white_red, minimum=0, maximum=100
# Color by pLDDT score (stored in B-factor column)

Quick pLDDT Analysis

import numpy as np

# Parse B-factor (pLDDT) from PDB
plddt_scores = []
with open('ranked_0.pdb', 'r') as f:
    for line in f:
        if line.startswith('ATOM'):
            plddt = float(line[60:66].strip())
            plddt_scores.append(plddt)

print(f"Mean pLDDT: {np.mean(plddt_scores):.1f}")
print(f"Residues >90 pLDDT: {sum(s > 90 for s in plddt_scores)}/{len(plddt_scores)}")

---

Using ColabFold (Faster Alternative)

ColabFold is a faster AlphaFold2 implementation using MMseqs2 for MSA generation:

pip install colabfold[alphafold]

# Run prediction (much faster MSA step)
colabfold_batch /tmp/target_protein.fasta /tmp/colabfold_output \
    --num-recycle 3 \
    --use-gpu-relax

ColabFold is typically 10–40x faster than the original AlphaFold2 pipeline due to the MMseqs2 MSA server. Ideal for iterative research workflows.

---

Troubleshooting

CUDA Out of Memory

# Reduce model complexity or use unified memory
export XLA_PYTHON_CLIENT_ALLOCATOR=platform
export XLA_PYTHON_CLIENT_MEM_FRACTION=0.85

# Or run with reduced recycling
--num_multimer_predictions_per_model 1

HHblits / Jackhmmer Errors

# Ensure hhsuite is properly installed
which hhblits
hhblits --version

# Reinstall if needed
conda install -c bioconda hhsuite -y

Database Download Failures

# Resume interrupted downloads with aria2
aria2c -c -x 16 -s 16 <database-url> -d /data/alphafold_databases/

JAX/CUDA Compatibility Issues

# Check JAX can see GPU
python3 -c "import jax; print(jax.devices())"

# Reinstall JAX with correct CUDA version
pip install --upgrade "jax[cuda11_pip]" \
    -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

---

Performance Tips

Optimize Your AlphaFold2 Runs:

1. Use ColabFold for faster MSA generation (10–40x speedup)

2. Set --num-recycle 1 for quick screening, use 3 for final predictions

3. Use --db_preset=reduced_dbs for exploratory work

4. Batch multiple sequences in one FASTA file for efficient pipeline runs

5. Enable GPU relaxation (--use_gpu_relax=True) — much faster than CPU relaxation

---

Cost Estimation on Clore.ai

Scenario	GPU	Est. Time	Est. Cost
Single protein (~300aa)	RTX 3090	1–2h	~$0.30–0.60
Single protein (~500aa)	RTX 4090	45–90min	~$0.40–0.80
Multimer complex	A100 80GB	2–4h	~$1.50–3.00
Proteome screening (100 proteins)	A100 80GB	8–12h	~$6–10

Costs are approximate and depend on current marketplace pricing.

---

Additional Resources

• AlphaFold2 GitHub

• AlphaFold Database — Pre-computed structures for 200M+ proteins

• ColabFold GitHub

• DeepMind AlphaFold Blog

• OpenFold — Trainable PyTorch reimplementation

• ESMFold — Meta's faster alternative

---

This guide covers AlphaFold2 deployment on Clore.ai GPU rentals. For the latest AlphaFold3, see the separate AlphaFold3 guide.

---

Clore.ai GPU Recommendations

Use Case	Recommended GPU	Est. Cost on Clore.ai
Development/Testing	RTX 3090 (24GB)	~$0.12/gpu/hr
Standard Proteins	RTX 4090 (24GB)	~$0.70/gpu/hr
Large Molecules / Multimers	A100 80GB	~$1.20/gpu/hr

💡 All examples in this guide can be deployed on Clore.ai GPU servers. Browse available GPUs and rent by the hour — no commitments, full root access.