> 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-fr/science-et-recherche/alphafold2.md).

# Prédiction de protéines AlphaFold2

> **Prédisez des structures protéiques avec une IA primée par le prix Nobel — accélérée par GPU sur Clore.ai**

AlphaFold2, développé par DeepMind, a révolutionné la biologie structurale en prédisant des structures 3D de protéines avec une précision atomique. Il a été appliqué à plus de 200 millions de séquences protéiques et a remporté le prix Nobel de chimie 2024. L’exécution d’AlphaFold2 nécessite une mémoire GPU et des capacités de calcul importantes — Clore.ai fournit un accès abordable aux GPU haut de gamme nécessaires.

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

***

## Prérequis

* Un compte Clore.ai avec un solde suffisant
* Une connaissance de base de la ligne de commande Linux
* Votre ou vos séquence(s) protéique(s) cible au format FASTA
* \~2,5 To d'espace disque pour les bases de données génétiques complètes (ou utilisez les bases de données réduites pour les tests)

***

## Pourquoi exécuter AlphaFold2 sur Clore.ai ?

AlphaFold2 tire énormément parti de l’accélération GPU :

| Matériel             | Temps de prédiction (protéine typique \~400 aa) |
| -------------------- | ----------------------------------------------- |
| CPU uniquement       | 6–24+ heures                                    |
| Une seule A100 80 Go | 15–45 minutes                                   |
| Une seule RTX 4090   | 20–60 minutes                                   |
| Une seule RTX 3090   | 30–90 minutes                                   |

Clore.ai propose des nœuds A100, RTX 4090 et RTX 3090 à une fraction du coût des fournisseurs cloud, rendant accessibles les études de protéomique à grande échelle.

***

## Étape 1 — Choisissez votre location GPU sur Clore.ai

{% hint style="info" %}
**GPU recommandés pour AlphaFold2 :**

* **A100 80 Go** — Idéal pour les grandes protéines (>700 aa) et la prédiction de multimères
* **RTX 4090 24 Go** — Parfait pour les monomères standard (<500 aa)
* **RTX 3090 24 Go** — Économique pour les petites protéines

Pour la prédiction de multimères, 40 Go+ de VRAM sont fortement recommandés.
{% endhint %}

1. Connectez-vous à [clore.ai](https://clore.ai) et allez à **Place de marché**
2. Filtrez par modèle de GPU (A100 ou RTX 4090 recommandé)
3. Vérifiez que le serveur dispose de **d’au moins 100 Go d’espace disque** (ou 2,5 To pour les bases complètes)
4. Sélectionnez un serveur et cliquez sur **Louer**

***

## Étape 2 — Configurez votre déploiement

Lors de la configuration de votre commande de location, utilisez la configuration suivante :

**Image Docker :**

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

{% hint style="warning" %}
AlphaFold2 nécessite une configuration Docker personnalisée. Nous l’installerons à partir des sources dans le conteneur. Vous pouvez également utiliser l’image communautaire `catgumag/alphafold` ou `merteroglu/alphafold2` qui préconfigure l’environnement.
{% endhint %}

**Ports à exposer :**

```
22
```

**Variables d'environnement :**

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

**Ressources minimales :**

* CPU : 8 cœurs
* RAM : 32 Go (64 Go recommandés pour les grandes protéines)
* Disque : 100 Go minimum (2,5 To pour les bases complètes)

***

## Étape 3 — Connectez-vous via SSH

Une fois votre instance en cours d’exécution :

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

Vérifiez que le GPU est visible :

```bash
nvidia-smi
```

La sortie attendue doit afficher votre GPU (par ex. A100 80GB SXM4).

***

## Étape 4 — Installez AlphaFold2

### Option A : Utilisation du script d’installation officiel

```bash
# Mettre à jour les paquets système
apt-get update && apt-get install -y \\
    wget \
    git \
    python3-pip \
    python3-dev \\
    aria2 \\
    hmmer \\
    kalign \\
    hhsuite

# Installer 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"

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

# Créer l’environnement conda
conda env create -f environment.yml
conda activate alphafold
```

### Option B : Utilisation de pip (installation plus rapide)

```bash
# Installez les dépendances système
apt-get update && apt-get install -y \\
    wget curl git aria2 hmmer kalign

# Installer hhsuite
conda install -c bioconda hhsuite

# Cloner et installer 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

# Installer AlphaFold lui-même
python3 setup.py install
```

***

## Étape 5 — Téléchargez les bases de données génétiques

{% hint style="warning" %}
**Le téléchargement complet des bases nécessite \~2,5 To d’espace disque et peut prendre 6–24 heures.** Pour les premiers tests, utilisez les bases réduites (voir la section Base de données réduite ci-dessous).
{% endhint %}

### Bases de données complètes (utilisation en production)

```bash
cd /opt/alphafold

# Télécharger toutes les bases de données à l’aide du script fourni
bash scripts/download_all_data.sh /data/alphafold_databases
```

Cela télécharge :

* **BFD** (\~270GB) — Grande base de données fantastique
* **UniRef90** (\~58GB) — Groupes de référence UniProt
* **MGnify** (\~64GB) — Séquences métagénomiques
* **PDB70** (\~56GB) — Structures représentatives de la Protein Data Bank
* **PDB seqres** (\~0.2GB)
* **UniClust30** (\~86GB)
* **Small BFD** (\~17GB) — Version réduite

### Bases de données réduites (test/développement)

Pour les tests sur un espace disque limité :

```bash
# Télécharger uniquement small_bfd et les bases de données nécessaires
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
```

***

## Étape 6 — Téléchargez les poids du modèle AlphaFold

```bash
# Créer le répertoire des paramètres du modèle
mkdir -p /data/alphafold_databases/params

# Télécharger les paramètres du modèle (~3,5 Go)
wget -q -P /data/alphafold_databases/params \\
    https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar

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

***

## Étape 7 — Préparez votre séquence d'entrée

Créez un fichier FASTA avec votre séquence protéique cible :

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

{% hint style="info" %}
**Conseils pour le format FASTA :**

* La ligne d'en-tête commence par `>`
* La séquence doit contenir uniquement les lettres standard des acides aminés (ACDEFGHIKLMNPQRSTVWY)
* Supprimez tous les espaces ou caractères non standard
* Pour la prédiction de multimères, incluez toutes les chaînes avec des en-têtes séparés
  {% endhint %}

***

## Étape 8 — Exécutez AlphaFold2

### Prédiction monomérique (chaîne unique)

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

### Prédiction multimer (complexe protéique)

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

***

## Étape 9 — Comprendre les fichiers de sortie

AlphaFold2 produit plusieurs fichiers de sortie par prédiction :

```
/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Meilleure structure prédite
├── ranked_1.pdb          # Deuxième meilleure prédiction
├── ranked_2.pdb
├── ranked_3.pdb
├── ranked_4.pdb
├── result_model_1.pkl    # Données complètes de prédiction (pickle)
├── result_model_2.pkl
├── ...
├── msas/                 # Alignements multiples de séquences
│   ├── bfd_uniclust_hits.a3m
│   ├── mgnify_hits.sto
│   └── uniref90_hits.sto
└── timings.json          # Répartition du temps d’exécution
```

{% hint style="info" %}
**Interprétation des résultats :**

* **ranked\_0.pdb** est votre meilleure structure — ouvrez-la dans PyMOL, ChimeraX ou UCSF Chimera
* **score pLDDT** (0–100) : confiance par résidu. >90 = très élevée, 70–90 = bonne, 50–70 = faible, <50 = désordonnée
* **PAE (erreur d’alignement prédite)** les graphiques montrent la confiance inter-domaines
  {% endhint %}

***

## Étape 10 — Visualisez les résultats

### Téléchargez les fichiers PDB sur votre machine locale

```bash
# Depuis votre machine locale :
scp -P <ssh-port> root@<server-ip>:/tmp/alphafold_output/my_protein/ranked_0.pdb ./

# Ou utilisez rsync pour le répertoire de sortie complet :
rsync -avz -e "ssh -p <ssh-port>" \\
    root@<server-ip>:/tmp/alphafold_output/ \\
    ./alphafold_results/
```

### Visualisez dans PyMOL (localement)

```python
# Dans PyMOL :
load ranked_0.pdb
spectrum b, blue_white_red, minimum=0, maximum=100
# Colorer selon le score pLDDT (stocké dans la colonne B-factor)
```

### Analyse rapide du pLDDT

```python
import numpy as np

# Analyser le B-factor (pLDDT) depuis le 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"Moyenne pLDDT : {np.mean(plddt_scores):.1f}")
print(f"Résidus >90 pLDDT : {sum(s > 90 for s in plddt_scores)}/{len(plddt_scores)}")
```

***

## Utilisation de ColabFold (alternative plus rapide)

ColabFold est une implémentation plus rapide d'AlphaFold2 utilisant MMseqs2 pour la génération de l'alignement multiple de séquences :

```bash
pip install colabfold[alphafold]

# Lancer la prédiction (étape MSA beaucoup plus rapide)
colabfold_batch /tmp/target_protein.fasta /tmp/colabfold_output \\
    --num-recycle 3 \\
    --use-gpu-relax
```

{% hint style="success" %}
**ColabFold est généralement 10 à 40 fois plus rapide** que le pipeline AlphaFold2 d'origine grâce au serveur MSA MMseqs2. Idéal pour les flux de travail de recherche itératifs.
{% endhint %}

***

## Dépannage

### Mémoire CUDA insuffisante

```bash
# Réduire la complexité du modèle ou utiliser la mémoire unifiée
export XLA_PYTHON_CLIENT_ALLOCATOR=platform
export XLA_PYTHON_CLIENT_MEM_FRACTION=0.85

# Ou exécuter avec un recyclage réduit
--num_multimer_predictions_per_model 1
```

### Erreurs HHblits / Jackhmmer

```bash
# Vérifiez que hhsuite est correctement installé
which hhblits
hhblits --version

# Réinstaller si nécessaire
conda install -c bioconda hhsuite -y
```

### Échecs de téléchargement de la base de données

```bash
# Reprendre les téléchargements interrompus avec aria2
aria2c -c -x 16 -s 16 <database-url> -d /data/alphafold_databases/
```

### Problèmes de compatibilité JAX/CUDA

```bash
# Vérifiez que JAX détecte le GPU
python3 -c "import jax; print(jax.devices())"

# Réinstallez JAX avec la bonne version de CUDA
pip install --upgrade "jax[cuda11_pip]" \\
    -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

***

## Conseils de performance

{% hint style="success" %}
**Optimisez vos exécutions AlphaFold2 :**

1. **Utilisez ColabFold** pour une génération MSA plus rapide (accélération 10 à 40 fois)
2. **Définissez `--num-recycle 1`** pour un criblage rapide, utilisez 3 pour les prédictions finales
3. **Utilisez `--db_preset=reduced_dbs`** pour les travaux exploratoires
4. **Regroupez plusieurs séquences** dans un seul fichier FASTA pour des exécutions de pipeline efficaces
5. **Activez la relaxation GPU** (`--use_gpu_relax=True`) — beaucoup plus rapide que la relaxation CPU
   {% endhint %}

***

## Estimation des coûts sur Clore.ai

| Scénario                             | GPU        | Temps estimé | Coût estimé   |
| ------------------------------------ | ---------- | ------------ | ------------- |
| Protéine unique (\~300 aa)           | RTX 3090   | 1–2 h        | \~0,30–0,60 $ |
| Protéine unique (\~500 aa)           | RTX 4090   | 45–90 min    | \~0,40–0,80 $ |
| Complexe multimer                    | A100 80 Go | 2–4 h        | \~1,50–3,00 $ |
| Criblage du protéome (100 protéines) | A100 80 Go | 8–12 h       | \~6–10 $      |

*Les coûts sont approximatifs et dépendent des tarifs actuels du marché.*

***

## Ressources supplémentaires

* [AlphaFold2 GitHub](https://github.com/google-deepmind/alphafold)
* [Base de données AlphaFold](https://alphafold.ebi.ac.uk/) — Structures pré-calculées pour plus de 200 millions de protéines
* [ColabFold GitHub](https://github.com/sokrypton/ColabFold)
* [Blog AlphaFold de DeepMind](https://www.deepmind.com/research/highlighted-research/alphafold)
* [OpenFold](https://github.com/aqlaboratory/openfold) — Réimplémentation entraînable sous PyTorch
* [ESMFold](https://github.com/facebookresearch/esm) — L’alternative plus rapide de Meta

***

*Ce guide couvre le déploiement d’AlphaFold2 sur les locations GPU de Clore.ai. Pour la dernière version AlphaFold3, consultez le guide AlphaFold3 séparé.*

***

## Recommandations GPU Clore.ai

| Cas d’utilisation              | GPU recommandé   | Coût estimé sur Clore.ai                  |
| ------------------------------ | ---------------- | ----------------------------------------- |
| Développement/Test             | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h                         |
| Protéines standard             | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h                         |
| Grandes molécules / multimères | A100 80 Go       | [bare metal](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# 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-fr/science-et-recherche/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.