> 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 Nobelpreis-gekrönter KI vorhersagen — angetrieben durch GPU-Beschleunigung auf Clore.ai**

AlphaFold2, entwickelt von DeepMind, revolutionierte die Strukturbiologie, indem es 3D-Proteinstrukturen mit atomarer Genauigkeit vorhersagt. Es wurde auf über 200 Millionen Proteinsequenzen angewendet und erhielt den Nobelpreis für Chemie 2024. Der Betrieb von AlphaFold2 erfordert erheblichen GPU-Speicher und Rechenleistung — Clore.ai bietet erschwinglichen Zugang zu den High-End-GPUs, die dafür benötigt werden.

**GitHub:** [google-deepmind/alphafold](https://github.com/google-deepmind/alphafold) — 13 Tsd.+ ⭐

***

## Voraussetzungen

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

***

## Warum AlphaFold2 auf Clore.ai ausführen?

AlphaFold2 profitiert enorm von GPU-Beschleunigung:

| Hardware                | Vorhersagezeit (typisches Protein \~400 AS) |
| ----------------------- | ------------------------------------------- |
| Nur CPU                 | 6–24+ Stunden                               |
| Eine einzelne A100 80GB | 15–45 Minuten                               |
| Eine einzelne RTX 4090  | 20–60 Minuten                               |
| Eine einzelne RTX 3090  | 30–90 Minuten                               |

Clore.ai bietet A100-, RTX-4090- und RTX-3090-Knoten zu einem Bruchteil der Kosten von Cloud-Anbietern an und macht so 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 AS) und Multimer-Vorhersagen
* **RTX 4090 24GB** — Ideal für Standard-Monomere (<500 AS)
* **RTX 3090 24 GB** — Kosteneffizient für kleinere Proteine

Für Multimer-Vorhersagen werden 40 GB+ VRAM dringend empfohlen.
{% endhint %}

1. Melde dich 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 aus und klicken Sie auf **Mieten**

***

## Schritt 2 — Konfigurieren Sie Ihre Bereitstellung

Wenn Sie Ihre Mietbestellung einrichten, verwenden Sie die folgende Konfiguration:

**Docker-Image:**

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

{% hint style="warning" %}
AlphaFold2 erfordert ein benutzerdefiniertes Docker-Setup. Wir werden es aus dem Quellcode innerhalb des Containers installieren. Alternativ verwenden Sie das Community-Image `catgumag/alphafold` oder `merteroglu/alphafold2` das die Umgebung vorab paketiert.
{% endhint %}

**Zu öffnende Ports:**

```
22
```

**Umgebungsvariablen:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
```

**Mindestanforderungen:**

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

***

## Schritt 3 — Per SSH verbinden

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: Mit dem offiziellen Installationsskript

```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: Mit 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 Download der Datenbank erfordert etwa 2,5 TB Speicherplatz und kann 6–24 Stunden dauern.** Für erste Tests verwenden Sie die reduzierten Datenbanken (siehe Abschnitt Reduzierte DB unten).
{% endhint %}

### Vollständige Datenbanken (Produktionseinsatz)

```bash
cd /opt/alphafold

# Alle Datenbanken mit dem bereitgestellten Skript herunterladen
bash scripts/download_all_data.sh /data/alphafold_databases
```

Dies lädt herunter:

* **BFD** (\~270 GB) — Große fantastische Datenbank
* **UniRef90** (\~58 GB) — UniProt-Referenzcluster
* **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 (Testentwicklung)

Für Tests auf begrenztem Speicher:

```bash
# Nur small_bfd und notwendige Datenbanken herunterladen
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" %}
**Tipps zum FASTA-Format:**

* Die Kopfzeile beginnt mit `>`
* Die Sequenz sollte nur standardmäßige 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 Kopfzeilen 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 (Proteinkomplex)

```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 — Ausgabedateien verstehen

AlphaFold2 erzeugt pro Vorhersage mehrere Ausgabedateien:

```
/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Beste vorhergesagte 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 Sequenzalignments
│   ├── bfd_uniclust_hits.a3m
│   ├── mgnify_hits.sto
│   └── uniref90_hits.sto
└── timings.json          # Laufzeitaufteilung
```

{% 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): Konfidenz pro Rest. >90 = sehr hoch, 70–90 = gut, 50–70 = niedrig, <50 = ungeordnet
* **PAE (Predicted Aligned Error)** Diagramme zeigen die Konfidenz zwischen Domänen
  {% endhint %}

***

## Schritt 10 — Ergebnisse visualisieren

### PDB-Dateien auf Ihren lokalen Rechner herunterladen

```bash
# Von Ihrem lokalen Rechner 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 einfärben (im B-Faktor-Feld gespeichert)
```

### Schnelle pLDDT-Analyse

```python
import numpy as np

# B-Faktor (pLDDT) aus der 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-Generierung verwendet:

```bash
pip install colabfold[alphafold]

# Vorhersage ausführen (deutlich 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, dank des MMseqs2-MSA-Servers. Ideal für iterative Forschungsabläufe.
{% endhint %}

***

## Fehlerbehebung

### CUDA Out of Memory

```bash
# Modellkomplexität reduzieren oder Unified Memory verwenden
export XLA_PYTHON_CLIENT_ALLOCATOR=platform
export XLA_PYTHON_CLIENT_MEM_FRACTION=0.85

# Oder mit reduziertem Recycling 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
```

### Fehler beim Herunterladen der Datenbank

```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 sehen kann
python3 -c "import jax; print(jax.devices())"

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

***

## Leistungstipps

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

1. **ColabFold verwenden** für schnellere MSA-Generierung (10–40x Beschleunigung)
2. **Setze `--num-recycle 1`** für schnelles Screening; 3 für Endvorhersagen verwenden
3. **Verwende `--db_preset=reduced_dbs`** für explorative Arbeiten
4. **Mehrere Sequenzen bündeln** in einer einzigen 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ätzte Zeit | Geschätzte Kosten |
| -------------------------------- | --------- | --------------- | ----------------- |
| Einzelprotein (\~300 AS)         | RTX 3090  | 1–2 Std.        | \~0,30–0,60 $     |
| Einzelprotein (\~500 AS)         | RTX 4090  | 45–90 Min.      | \~0,40–0,80 $     |
| Multimer-Komplex                 | A100 80GB | 2–4 Std.        | \~1,50–3,00 $     |
| Proteom-Screening (100 Proteine) | A100 80GB | 8–12 Std.       | \~6–10 $          |

*Die Kosten sind приблизit und hängen von den aktuellen Marktpreisen ab.*

***

## Zusätzliche Ressourcen

* [AlphaFold2 GitHub](https://github.com/google-deepmind/alphafold)
* [AlphaFold-Datenbank](https://alphafold.ebi.ac.uk/) — Vorberechnete Strukturen für über 200 Mio. 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 AlphaFold2-Bereitstellung auf GPU-Mieten bei Clore.ai. Für das neueste AlphaFold3 siehe die separate AlphaFold3-Anleitung.*

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall             | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai            |
| -------------------------- | ---------------- | ----------------------------------------- |
| Entwicklung/Testen         | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde                    |
| Standardproteine           | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde                    |
| Große Moleküle / Multimere | A100 80GB        | [Bare Metal](https://clore.ai/bare-metal) |

> 💡 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.