> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/wissenschaft-and-forschung/alphafold2.md).

# 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](https://github.com/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

{% hint style="info" %}
**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.
{% endhint %}

1. Melden Sie sich an bei [clore.ai](https://clore.ai) und gehen Sie zu **Marktplatz**
2. Nach GPU-Modell filtern (A100 oder RTX 4090 empfohlen)
3. Stellen Sie sicher, dass der Server **mindestens 100 GB Festplattenspeicher hat** (oder 2,5 TB für vollständige Datenbanken)
4. 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
```

{% hint style="warning" %}
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.
{% endhint %}

**Zu öffnende Ports:**

```
22
```

**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:

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

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

```bash
nvidia-smi
```

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

***

## Schritt 4 — AlphaFold2 installieren

### Option A: Verwendung des offiziellen Installationsskripts

```bash
# 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)

```bash
# 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

{% hint style="warning" %}
**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).
{% endhint %}

### Vollständige Datenbanken (Produktivbetrieb)

```bash
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:

```bash
# 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

```bash
# 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:

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

{% hint style="info" %}
**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
  {% endhint %}

***

## Schritt 8 — AlphaFold2 ausführen

### Monomer-Vorhersage (Einzelkette)

```bash
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)

```bash
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
```

{% hint style="info" %}
**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
  {% endhint %}

***

## Schritt 10 — Ergebnisse visualisieren

### PDB-Dateien auf Ihre lokale Maschine herunterladen

```bash
# 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)

```python
# 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

```python
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:

```bash
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
```

{% hint style="success" %}
**ColabFold ist typischerweise 10–40x schneller** als die ursprüngliche AlphaFold2-Pipeline aufgrund des MMseqs2-MSA-Servers. Ideal für iterative Forschungs-Workflows.
{% endhint %}

***

## Fehlerbehebung

### CUDA Out of Memory

```bash
# 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

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

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

### Datenbank-Downloadfehler

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

### JAX/CUDA-Kompatibilitätsprobleme

```bash
# 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

{% hint style="success" %}
**Optimieren Sie Ihre AlphaFold2-Läufe:**

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

***

## 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](https://github.com/google-deepmind/alphafold)
* [AlphaFold-Datenbank](https://alphafold.ebi.ac.uk/) — Vorgecompute Strukturen für 200M+ Proteine
* [ColabFold GitHub](https://github.com/sokrypton/ColabFold)
* [DeepMind AlphaFold Blog](https://www.deepmind.com/research/highlighted-research/alphafold)
* [OpenFold](https://github.com/aqlaboratory/openfold) — Trainierbare PyTorch-Neuimplementierung
* [ESMFold](https://github.com/facebookresearch/esm) — 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](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/wissenschaft-and-forschung/alphafold2.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.