AlphaFold2 Proteinvorhersage

Proteinstrukturen mit der Nobelpreis-prämierten KI vorhersagen – beschleunigt durch GPUs auf Clore.ai

AlphaFold2, entwickelt von DeepMind, revolutionierte die Strukturbiologie durch die Vorhersage von Protein-3D-Strukturen mit atomarer Genauigkeit. Es wurde auf über 200 Millionen Proteinsequenzen angewendet und erhielt den Nobelpreis für Chemie 2024. Das Ausführen von AlphaFold2 erfordert erheblichen GPU-Speicher und Rechenleistung – Clore.ai bietet erschwinglichen Zugang zu den dafür benötigten High-End-GPUs.

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

Voraussetzungen

Ein Clore.ai-Konto mit ausreichendem Guthaben
Grundlegende Vertrautheit mit der Linux-Kommandozeile
Ihre Ziel-Proteinsequenz(en) im FASTA-Format
~2,5 TB Festplattenspeicher für die vollständigen genetischen Datenbanken (oder verwenden Sie reduzierte Datenbanken zum Testen)

Warum AlphaFold2 auf Clore.ai ausführen?

AlphaFold2 profitiert enorm von GPU-Beschleunigung:

Hardware

Vorhersagezeit (typisches Protein ~400 aa)

Nur CPU

6–24+ Stunden

Single A100 80GB

15–45 Minuten

Single RTX 4090

20–60 Minuten

Single RTX 3090

30–90 Minuten

Clore.ai bietet A100-, RTX 4090- und RTX 3090-Knoten zu einem Bruchteil der Kosten von Cloud-Anbietern und macht groß angelegte Proteomik-Studien zugänglich.

Schritt 1 — Wählen Sie Ihre GPU-Miete auf Clore.ai

Empfohlene GPUs für AlphaFold2:

A100 80GB — Am besten für große Proteine (>700 aa) und Multimer-Vorhersagen
RTX 4090 24GB — Hervorragend für typische Monomere (<500 aa)
RTX 3090 24GB — Kosten-effektiv für kleinere Proteine

Für Multimer-Vorhersagen werden 40 GB+ VRAM dringend empfohlen.

Melden Sie sich an bei clore.ai und gehen Sie zu Marktplatz
Nach GPU-Modell filtern (A100 oder RTX 4090 empfohlen)
Stellen Sie sicher, dass der Server mindestens 100 GB Festplattenspeicher hat (oder 2,5 TB für vollständige Datenbanken)
Wählen Sie einen Server und klicken Sie auf Mieten

Schritt 2 — Konfigurieren Sie Ihre Bereitstellung

Beim Einrichten Ihrer Mietbestellung verwenden Sie die folgende Konfiguration:

Docker-Image:

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

AlphaFold2 benötigt ein benutzerdefiniertes Docker-Setup. Wir werden es im Container aus dem Quellcode installieren. Alternativ können Sie das Community-Image verwenden catgumag/alphafold oder merteroglu/alphafold2 das die Umgebung vorverpackt.

Zu öffnende Ports:

Umgebungsvariablen:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

Mindestressourcen:

CPU: 8 Kerne
RAM: 32 GB (64 GB empfohlen für große Proteine)
Festplatte: mindestens 100 GB (2,5 TB für vollständige Datenbanken)

Schritt 3 — Verbinden Sie sich per SSH

Sobald Ihre Instanz läuft:

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

Überprüfen Sie, ob die GPU sichtbar ist:

nvidia-smi

Die erwartete Ausgabe sollte Ihre GPU anzeigen (z. B. A100 80GB SXM4).

Schritt 4 — AlphaFold2 installieren

Option A: Verwendung des offiziellen Installationsskripts

# Systempakete aktualisieren
apt-get update && apt-get install -y \
    wget \
    git \
    python3-pip \
    python3-dev \
    aria2 \
    hmmer \
    kalign \
    hhsuite

# Miniconda installieren
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"

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

# Conda-Umgebung erstellen
conda env create -f environment.yml
conda activate alphafold

Option B: Verwendung von pip (schnellere Einrichtung)

# Systemabhängigkeiten installieren
apt-get update && apt-get install -y \
    wget curl git aria2 hmmer kalign

# hhsuite installieren
conda install -c bioconda hhsuite

# AlphaFold2 klonen und installieren
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

# AlphaFold selbst installieren
python3 setup.py install

Schritt 5 — Genetische Datenbanken herunterladen

Der vollständige Datenbank-Download benötigt ~2,5 TB Festplattenspeicher und kann 6–24 Stunden dauern. Für erste Tests verwenden Sie die reduzierten Datenbanken (siehe Abschnitt Reduzierte DB weiter unten).

Vollständige Datenbanken (Produktivbetrieb)

cd /opt/alphafold

# Laden Sie alle Datenbanken mit dem bereitgestellten Skript herunter
bash scripts/download_all_data.sh /data/alphafold_databases

Dies lädt herunter:

BFD (~270 GB) — Big Fantastic Database
UniRef90 (~58 GB) — UniProt Reference Clusters
MGnify (~64 GB) — Metagenomik-Sequenzen
PDB70 (~56 GB) — Repräsentative Strukturen der Protein Data Bank
PDB seqres (~0,2 GB)
UniClust30 (~86 GB)
Small BFD (~17 GB) — Reduzierte Version

Reduzierte Datenbanken (Test/Entwicklung)

Für Tests mit begrenztem Speicherplatz:

# Laden Sie nur small_bfd und notwendige Datenbanken herunter
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

Schritt 6 — AlphaFold-Modellgewichte herunterladen

# Verzeichnis für Modellparameter erstellen
mkdir -p /data/alphafold_databases/params

# Modellparameter herunterladen (~3,5 GB)
wget -q -P /data/alphafold_databases/params \
    https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar

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

Schritt 7 — Bereiten Sie Ihre Eingabesequenz vor

Erstellen Sie eine FASTA-Datei mit Ihrer Ziel-Proteinsequenz:

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

FASTA-Format Tipps:

Die Header-Zeile beginnt mit >
Die Sequenz sollte nur Standard-Aminosäurebuchstaben enthalten (ACDEFGHIKLMNPQRSTVWY)
Entfernen Sie alle Lücken oder nicht-standardmäßigen Zeichen
Für Multimer-Vorhersagen fügen Sie alle Ketten mit separaten Headern ein

Schritt 8 — AlphaFold2 ausführen

Monomer-Vorhersage (Einzelkette)

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-Vorhersage (Protein-Komplex)

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

Schritt 9 — Die Ausgabedateien verstehen

AlphaFold2 erzeugt mehrere Ausgabedateien pro Vorhersage:

/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Beste vorhergesene Struktur
├── ranked_1.pdb          # Zweitbeste Vorhersage
├── ranked_2.pdb
├── ranked_3.pdb
├── ranked_4.pdb
├── result_model_1.pkl    # Vollständige Vorhersagedaten (Pickle)
├── result_model_2.pkl
├── ...
├── msas/                 # Multiple Sequence Alignments
│   ├── bfd_uniclust_hits.a3m
│   ├── mgnify_hits.sto
│   └── uniref90_hits.sto
└── timings.json          # Laufzeit-Aufschlüsselung

Ergebnisse interpretieren:

ranked_0.pdb ist Ihre beste Struktur — öffnen Sie sie in PyMOL, ChimeraX oder UCSF Chimera
pLDDT-Score (0–100): pro-Residuum-Vertrauen. >90 = sehr hoch, 70–90 = gut, 50–70 = niedrig, <50 = ungeordnet
PAE (Predicted Aligned Error) Plots zeigen das Vertrauen zwischen Domänen

Schritt 10 — Ergebnisse visualisieren

PDB-Dateien auf Ihre lokale Maschine herunterladen

# Von Ihrer lokalen Maschine aus:
scp -P <ssh-port> root@<server-ip>:/tmp/alphafold_output/my_protein/ranked_0.pdb ./

# Oder verwenden Sie rsync für das vollständige Ausgabeverzeichnis:
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/tmp/alphafold_output/ \
    ./alphafold_results/

In PyMOL visualisieren (lokal)

# In PyMOL:
load ranked_0.pdb
spectrum b, blue_white_red, minimum=0, maximum=100
# Nach pLDDT-Score färben (im B-Faktor-Feld gespeichert)

Schnelle pLDDT-Analyse

import numpy as np

# B-Faktor (pLDDT) aus PDB parsen
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)}")

Verwendung von ColabFold (schnellere Alternative)

ColabFold ist eine schnellere AlphaFold2-Implementierung, die MMseqs2 für die MSA-Erzeugung verwendet:

pip install colabfold[alphafold]

# Vorhersage ausführen (wesentlich schnellerer MSA-Schritt)
colabfold_batch /tmp/target_protein.fasta /tmp/colabfold_output \
    --num-recycle 3 \
    --use-gpu-relax

ColabFold ist typischerweise 10–40x schneller als die ursprüngliche AlphaFold2-Pipeline aufgrund des MMseqs2-MSA-Servers. Ideal für iterative Forschungs-Workflows.

Fehlerbehebung

CUDA Out of Memory

# Modellkomplexität reduzieren oder gemeinsam genutzten Speicher verwenden
export XLA_PYTHON_CLIENT_ALLOCATOR=platform
export XLA_PYTHON_CLIENT_MEM_FRACTION=0.85

# Oder mit reduzierter Rekursion ausführen
--num_multimer_predictions_per_model 1

HHblits / Jackhmmer-Fehler

# Stellen Sie sicher, dass hhsuite korrekt installiert ist
which hhblits
hhblits --version

# Bei Bedarf neu installieren
conda install -c bioconda hhsuite -y

Datenbank-Downloadfehler

# Unterbrochene Downloads mit aria2 fortsetzen
aria2c -c -x 16 -s 16 <database-url> -d /data/alphafold_databases/

JAX/CUDA-Kompatibilitätsprobleme

# Prüfen, ob JAX die GPU sieht
python3 -c "import jax; print(jax.devices())"

# JAX mit korrekter CUDA-Version neu installieren
pip install --upgrade "jax[cuda11_pip]" \
    -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

Leistungs-Tipps

Optimieren Sie Ihre AlphaFold2-Läufe:

Verwenden Sie ColabFold für schnellere MSA-Erzeugung (10–40x Beschleunigung)
Setzen Sie --num-recycle 1 für schnelles Screening, verwenden Sie 3 für finale Vorhersagen
Verwende --db_preset=reduced_dbs für explorative Arbeiten
Batchen Sie mehrere Sequenzen in einer FASTA-Datei für effiziente Pipeline-Läufe
GPU-Relaxation aktivieren (--use_gpu_relax=True) — viel schneller als CPU-Relaxation

Kostenschätzung auf Clore.ai

Szenario

GPU

Gesch. Zeit

Gesch. Kosten

Einzelprotein (~300 aa)

RTX 3090

1–2h

~$0.30–0.60

Einzelprotein (~500 aa)

RTX 4090

45–90min

~$0.40–0.80

Multimer-Komplex

A100 80GB

2–4h

~$1.50–3.00

Proteom-Screening (100 Proteine)

A100 80GB

8–12h

~$6–10

Die Kosten sind ungefähre Angaben und hängen von den aktuellen Marketplace-Preisen ab.

Zusätzliche Ressourcen

AlphaFold2 GitHub
AlphaFold-Datenbank — Vorgecompute Strukturen für 200M+ Proteine
ColabFold GitHub
DeepMind AlphaFold Blog
OpenFold — Trainierbare PyTorch-Neuimplementierung
ESMFold — Metas schnellere Alternative

Diese Anleitung behandelt die Bereitstellung von AlphaFold2 auf Clore.ai GPU-Mieten. Für das neueste AlphaFold3 siehe die separate AlphaFold3-Anleitung.

Clore.ai GPU-Empfehlungen

Anwendungsfall

Empfohlene GPU

Geschätzte Kosten auf Clore.ai

Entwicklung/Tests

RTX 3090 (24GB)

~$0.12/gpu/hr

Standardproteine

RTX 4090 (24GB)

~$0.70/gpu/hr

Große Moleküle / Multimere

A100 80GB

~$1.20/gpu/hr

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.

VorherigeÜbersicht NächsteESMFold Proteinstruktur

Zuletzt aktualisiert vor 12 Tagen

War das hilfreich?

hashtagVoraussetzungen

hashtagWarum AlphaFold2 auf Clore.ai ausführen?

hashtagSchritt 1 — Wählen Sie Ihre GPU-Miete auf Clore.ai

hashtagSchritt 2 — Konfigurieren Sie Ihre Bereitstellung

hashtagSchritt 3 — Verbinden Sie sich per SSH

hashtagSchritt 4 — AlphaFold2 installieren

hashtagOption A: Verwendung des offiziellen Installationsskripts

hashtagOption B: Verwendung von pip (schnellere Einrichtung)

hashtagSchritt 5 — Genetische Datenbanken herunterladen

hashtagVollständige Datenbanken (Produktivbetrieb)

hashtagReduzierte Datenbanken (Test/Entwicklung)

hashtagSchritt 6 — AlphaFold-Modellgewichte herunterladen

hashtagSchritt 7 — Bereiten Sie Ihre Eingabesequenz vor

hashtagSchritt 8 — AlphaFold2 ausführen

hashtagMonomer-Vorhersage (Einzelkette)

hashtagMultimer-Vorhersage (Protein-Komplex)

hashtagSchritt 9 — Die Ausgabedateien verstehen

hashtagSchritt 10 — Ergebnisse visualisieren

hashtagPDB-Dateien auf Ihre lokale Maschine herunterladen

hashtagIn PyMOL visualisieren (lokal)

hashtagSchnelle pLDDT-Analyse

hashtagVerwendung von ColabFold (schnellere Alternative)

hashtagFehlerbehebung

hashtagCUDA Out of Memory

hashtagHHblits / Jackhmmer-Fehler

hashtagDatenbank-Downloadfehler

hashtagJAX/CUDA-Kompatibilitätsprobleme

hashtagLeistungs-Tipps

hashtagKostenschätzung auf Clore.ai

hashtagZusätzliche Ressourcen

hashtagClore.ai GPU-Empfehlungen

Voraussetzungen

Warum AlphaFold2 auf Clore.ai ausführen?

Schritt 1 — Wählen Sie Ihre GPU-Miete auf Clore.ai

Schritt 2 — Konfigurieren Sie Ihre Bereitstellung

Schritt 3 — Verbinden Sie sich per SSH

Schritt 4 — AlphaFold2 installieren

Option A: Verwendung des offiziellen Installationsskripts

Option B: Verwendung von pip (schnellere Einrichtung)

Schritt 5 — Genetische Datenbanken herunterladen

Vollständige Datenbanken (Produktivbetrieb)

Reduzierte Datenbanken (Test/Entwicklung)

Schritt 6 — AlphaFold-Modellgewichte herunterladen

Schritt 7 — Bereiten Sie Ihre Eingabesequenz vor

Schritt 8 — AlphaFold2 ausführen

Monomer-Vorhersage (Einzelkette)

Multimer-Vorhersage (Protein-Komplex)

Schritt 9 — Die Ausgabedateien verstehen

Schritt 10 — Ergebnisse visualisieren

PDB-Dateien auf Ihre lokale Maschine herunterladen

In PyMOL visualisieren (lokal)

Schnelle pLDDT-Analyse

Verwendung von ColabFold (schnellere Alternative)

Fehlerbehebung

CUDA Out of Memory

HHblits / Jackhmmer-Fehler

Datenbank-Downloadfehler

JAX/CUDA-Kompatibilitätsprobleme

Leistungs-Tipps

Kostenschätzung auf Clore.ai

Zusätzliche Ressourcen

Clore.ai GPU-Empfehlungen