> 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 l'IA lauréate du prix Nobel — propulsée par l'accélération 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 reçu le prix Nobel de chimie 2024. Exécuter AlphaFold2 nécessite une mémoire GPU et une puissance de calcul importantes — Clore.ai fournit un accès abordable aux GPU haut de gamme requis.

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

***

## Prérequis

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

***

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

AlphaFold2 bénéficie énormément de l'accélération GPU :

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

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

***

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

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

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

Pour la prédiction de multimères, 40 Go ou plus 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és)
3. Assurez-vous que le serveur dispose de **au moins 100 Go d'espace disque** (ou 2,5 To pour les bases de données complètes)
4. Sélectionnez un serveur et cliquez sur **Louez**

***

## É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 depuis les sources à l'intérieur du conteneur. Alternativement, utilisez l'image communautaire `catgumag/alphafold` ou `merteroglu/alphafold2` qui préemballe 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 grosses 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 montrer 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
# Installer 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écharger les bases de données génétiques

{% hint style="warning" %}
**Le téléchargement des bases complètes nécessite \~2,5 To d'espace disque et peut prendre 6–24 heures.** Pour des tests initiaux, utilisez les bases réduites (voir la section Bases réduites ci-dessous).
{% endhint %}

### Bases complètes (usage en production)

```bash
cd /opt/alphafold

# Télécharger toutes les bases de données en utilisant le script fourni
bash scripts/download_all_data.sh /data/alphafold_databases
```

Cela télécharge :

* **BFD** (\~270 Go) — Big Fantastic Database
* **UniRef90** (\~58 Go) — UniProt Reference Clusters
* **MGnify** (\~64 Go) — Séquences métagénomiques
* **PDB70** (\~56 Go) — Structures représentatives de la Protein Data Bank
* **PDB seqres** (\~0,2 Go)
* **UniClust30** (\~86 Go)
* **Small BFD** (\~17 Go) — Version réduite

### Bases réduites (test/développement)

Pour les tests avec un espace disque limité :

```bash
# Télécharger seulement small_bfd et les bases 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écharger les poids des modèles AlphaFold

```bash
# Créer le répertoire pour les 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)
* Retirez tout gap ou caractère 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 de monomère (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 de multimère (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 la prédiction (pickle)
├── result_model_2.pkl
├── ...
├── msas/                 # Alignements de séquences multiples
│   ├── 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é
* **PAE (Predicted Aligned Error)** les graphiques montrent la confiance inter-domaines
  {% endhint %}

***

## Étape 10 — Visualiser les résultats

### Télécharger 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 complet de sortie :
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/tmp/alphafold_output/ \
    ./alphafold_results/
```

### Visualiser dans PyMOL (localement)

```python
# Dans PyMOL :
load ranked_0.pdb
spectrum b, blue_white_red, minimum=0, maximum=100
# Colorer par 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"Mean pLDDT: {np.mean(plddt_scores):.1f}")
print(f"Residues >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 des MSA :

```bash
pip install colabfold[alphafold]

# Exécuter 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–40x plus rapide** que le pipeline AlphaFold2 original grâce au serveur MSA MMseqs2. Idéal pour des flux de travail de recherche itératifs.
{% endhint %}

***

## Dépannage

### CUDA : mémoire 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
# Assurez-vous 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 bases 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érifier que JAX voit le GPU
python3 -c "import jax; print(jax.devices())"

# Réinstaller 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 de MSA plus rapide (accélération 10–40x)
2. **Définir `--num-recycle 1`** pour un criblage rapide, utilisez 3 pour les prédictions finales
3. **Utilisez `--db_preset=reduced_dbs`** pour le travail exploratoire
4. **Traitez plusieurs séquences en lot** 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–2h         | \~0,30–0,60 $ |
| Protéine unique (\~500 aa)           | RTX 4090  | 45–90 min    | \~0,40–0,80 $ |
| Complexe multimère                   | A100 80GB | 2–4h         | \~1,50–3,00 $ |
| Criblage de protéome (100 protéines) | A100 80GB | 8–12h        | \~6–10 $      |

*Les coûts sont approximatifs et dépendent des prix 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 200M 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 en PyTorch
* [ESMFold](https://github.com/facebookresearch/esm) — Alternative plus rapide de Meta

***

*Ce guide couvre le déploiement d'AlphaFold2 sur les locations GPU Clore.ai. Pour le dernier 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 (24GB) | \~$0.12/gpu/hr           |
| Protéines standard             | RTX 4090 (24GB) | \~$0.70/gpu/hr           |
| Grosses molécules / multimères | A100 80GB       | \~$1.20/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/science-et-recherche/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.