Structure des protéines ESMFold

Prédiction ultra-rapide de la structure des protéines par Meta AI — prédisez des structures protéiques 3D à partir de séquences d’acides aminés en quelques secondes, sans alignements multiples de séquences.

🧬 Développé par Meta AI Research | Licence MIT | 10 à 60 fois plus rapide qu'AlphaFold2

---

Qu'est-ce qu'ESMFold ?

ESMFold est le système de prédiction de structure protéique de Meta AI qui exploite Evolutionary Scale Modeling (ESM-2) — le plus grand modèle de langage pour protéines au monde (15 milliards de paramètres) — pour prédire directement des structures protéiques 3D à partir de séquences d’acides aminés.

Principaux avantages par rapport à AlphaFold2

Fonctionnalité	ESMFold	AlphaFold2
MSA requis	❌ Non	✅ Oui
Vitesse (protéine typique)	~2 secondes	~10 min à quelques heures
Précision (TM-score)	~0.87	~0.92
VRAM GPU (650 aa)	~8 Go	~8 Go
Entrée à séquence unique	✅ Oui	Limité
Protéines orphelines	✅ Excellente	Éprouve des difficultés

Pourquoi pas de MSA ?

AlphaFold2 nécessite un alignement multiple de séquences (MSA) — la collecte et l'alignement des proches évolutifs de la protéine requête. Cela est coûteux en calcul et impossible pour des protéines nouvelles ou conçues sans proches évolutifs.

ESMFold stocke l'information évolutive dans les poids de son modèle de langage (entraîné sur 250 millions de séquences protéiques), éliminant complètement la MSA. Cela le rend :

• Plus rapide : Aucune recherche de MSA (minutes économisées par prédiction)

• Plus évolutif : Traite efficacement des protéomes entiers

• Mieux adapté aux protéines nouvelles : Les séquences conçues n'ont aucun proche évolutif

---

Démarrage rapide sur Clore.ai

Étape 1 : Sélectionnez un serveur

Sur clore.ai place de marché :

• Minimum : GPU NVIDIA avec 16 Go de VRAM (le modèle de langage ESM-2 est volumineux)

• Recommandé : A100 40 Go, RTX 3090, RTX 4090 pour le modèle complet

• Option plus légère : Utilisez esm2_t33_650M_UR50D pour 8 Go de VRAM

Guide de VRAM GPU :

Longueur de la protéine	Variante du modèle	VRAM requise
Jusqu'à 300 aa	ESMFold (3B)	~16 Go
Jusqu'à 500 aa	ESMFold (3B)	~20 Go
Jusqu'à 1000 aa	ESMFold (3B)	~40 Go
Jusqu'à 600 aa	ESMFold (par morceaux)	~8 Go

Étape 2 : Construire une image Docker personnalisée

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

# Dépendances système
RUN apt-get update && apt-get install -y \
    git \
    wget \
    curl \
    openssh-server \
    libhdf5-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# Configurer SSH
RUN mkdir /var/run/sshd && \
    echo 'root:esmfold' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Installer ESMFold et les dépendances
RUN pip install --no-cache-dir \
    fair-esm[esmfold] \
    torch \
    biopython \
    biotite \
    fastapi \
    uvicorn \
    pydantic \
    openmm==8.0.0 \
    pdbfixer

# Installer OpenFold (requis pour ESMFold)
RUN pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

EXPOSE 22

CMD ["/usr/sbin/sshd", "-D"]

Étape 3 : déployez sur Clore.ai

• Image Docker : yourname/esmfold:latest

• Ports : 22 (SSH)

• Environnement : NVIDIA_VISIBLE_DEVICES=all

---

Installation et configuration

Méthode 1 : installation via pip

# Installer ESMFold
pip install fair-esm[esmfold]

# Installer OpenFold (dépendance requise)
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Facultatif mais recommandé
pip install biotite biopython

Méthode 2 : depuis les sources

git clone https://github.com/facebookresearch/esm.git
cd esm
pip install -e ".[esmfold]"

Vérifier l'installation

import esm
print("Version ESM :", esm.__version__)

# Test rapide de chargement du modèle
model = esm.pretrained.esmfold_v1()
print("ESMFold chargé avec succès !")

---

Utilisation de base

Prédire la structure d'une seule protéine

import torch
import esm

# Charger le modèle ESMFold
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()

# Facultatif : activer la taille de morceaux pour économiser la VRAM
# Augmente le temps de calcul mais réduit l'utilisation de la VRAM
model.set_chunk_size(64)  # Réduire pour moins de VRAM

# Séquence protéique (exemple : lysozyme C)
sequence = "KVFGRCELAAAMKRHGLDNYRGYSLGNWVCAAKFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSALLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL"

# Prédire la structure
with torch.no_grad():
    output = model.infer_pdb(sequence)

# Enregistrer le fichier PDB
with open("lysozyme.pdb", "w") as f:
    f.write(output)

print(f"Structure prédite ! Enregistrée dans lysozyme.pdb")
print(f"Longueur de la séquence : {len(sequence)} acides aminés")

Prédire plusieurs séquences (lot)

import torch
import esm

model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()

sequences = {
    "protein_A": "MKTAYIAKQRQISFVKSHFSRQ...",
    "protein_B": "MGDVEKGKKIFVQKCAQCHTVEK...",
    "ubiquitin": "MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG",
}

for name, seq in sequences.items():
    with torch.no_grad():
        output = model.infer_pdb(seq)
    
    with open(f"{name}.pdb", "w") as f:
        f.write(output)
    
    print(f"Prédit {name} : {len(seq)} aa")

print("Toutes les prédictions sont terminées !")

Obtenir la confiance par résidu (pLDDT)

import torch
import esm
import numpy as np

model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()

sequence = "MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG"

with torch.no_grad():
    output = model.infer(sequence)

# Extraire les scores pLDDT (confiance par résidu)
plddt = output["plddt"].cpu().numpy()  # Forme : [1, seq_len]
plddt_per_residue = plddt[0]

print(f"pLDDT moyen : {plddt_per_residue.mean():.2f}")
print(f"Résidus à forte confiance (>90) : {(plddt_per_residue > 90).sum()}")
print(f"Résidus à faible confiance (<50) : {(plddt_per_residue < 50).sum()}")

# Classer les régions de confiance
for i, score in enumerate(plddt_per_residue):
    if score >= 90:
        confidence = "Très élevée (bleu)"
    elif score >= 70:
        confidence = "Confiant (bleu clair)"
    elif score >= 50:
        confidence = "Faible (jaune)"
    else:
        confidence = "Très faible (orange)"
    # print(f"Résidu {i+1} : {score:.1f} - {confidence}")  # Décommentez pour l'affichage complet

---

Serveur d'API REST

Construire une API de production pour ESMFold :

# api_server.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import torch
import esm
import time
from typing import Optional

app = FastAPI(
    title="API de prédiction de structure protéique ESMFold",
    description="Prédire des structures protéiques 3D à partir de séquences d'acides aminés",
    version="1.0.0"
)

# Charger le modèle au démarrage
print("Chargement du modèle ESMFold (cela prend environ 30 secondes)...")
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()
model.set_chunk_size(64)  # Optimisation de la mémoire
print("ESMFold prêt !")

class PredictionRequest(BaseModel):
    sequence: str
    name: Optional[str] = "protein"

class PredictionResponse(BaseModel):
    name: str
    sequence_length: int
    pdb_content: str
    mean_plddt: float
    inference_time_seconds: float

@app.post("/predict", response_model=PredictionResponse)
async def predict_structure(request: PredictionRequest):
    """Prédire la structure 3D d'une protéine à partir de sa séquence d'acides aminés."""
    
    # Valider la séquence
    valid_aa = set("ACDEFGHIKLMNPQRSTVWY")
    sequence = request.sequence.upper().strip()
    
    invalid = set(sequence) - valid_aa
    if invalid:
        raise HTTPException(
            status_code=400,
            detail=f"Acides aminés invalides dans la séquence : {invalid}. Utilisez les 20 acides aminés standard."
        )
    
    if len(sequence) > 2000:
        raise HTTPException(
            status_code=400,
            detail="Séquence trop longue (2000 acides aminés max). Pour les séquences plus longues, utilisez une prédiction par morceaux."
        )
    
    start_time = time.time()
    
    try:
        with torch.no_grad():
            output = model.infer(sequence)
            pdb_content = model.output_to_pdb(output)[0]
            
        plddt = output["plddt"].cpu().numpy()[0]
        mean_plddt = float(plddt.mean())
        
    except torch.cuda.OutOfMemoryError:
        torch.cuda.empty_cache()
        raise HTTPException(
            status_code=507,
            detail="Mémoire GPU insuffisante. Essayez une séquence plus courte ou réduisez la taille des morceaux."
        )
    
    inference_time = time.time() - start_time
    
    return PredictionResponse(
        name=request.name,
        sequence_length=len(sequence),
        pdb_content=pdb_content,
        mean_plddt=mean_plddt,
        inference_time_seconds=round(inference_time, 2)
    )

@app.get("/health")
def health():
    gpu_mem = torch.cuda.memory_allocated() / 1024**3 if torch.cuda.is_available() else 0
    return {
        "status": "ok",
        "model": "ESMFold v1",
        "device": str(next(model.parameters()).device),
        "gpu_memory_gb": round(gpu_mem, 2)
    }

@app.get("/")
def root():
    return {"message": "API ESMFold — /predict pour prédire les structures, /docs pour l'interface Swagger"}

# Exécuter l'API
pip install fastapi uvicorn
uvicorn api_server:app --host 0.0.0.0 --port 8080 --workers 1

---

Exemples d'utilisation de l'API

# Prédire la structure via l'API
curl -X POST http://localhost:8080/predict \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ubiquitin",
    "sequence": "MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG"
  }' | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(f\"Nom : {data['name']}\")
print(f\"Longueur : {data['sequence_length']} aa\")
print(f\"pLDDT moyen : {data['mean_plddt']:.1f}\")
print(f\"Temps : {data['inference_time_seconds']}s\")
# Enregistrer le PDB
open('ubiquitin.pdb', 'w').write(data['pdb_content'])
print('PDB enregistré !')
"

---

Script de traitement par lot

# batch_predict.py
import torch
import esm
import os
from pathlib import Path
from Bio import SeqIO  # pip install biopython

def predict_fasta(fasta_file: str, output_dir: str, chunk_size: int = 64):
    """Prédire des structures pour toutes les séquences d'un fichier FASTA."""
    
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # Charger le modèle
    model = esm.pretrained.esmfold_v1()
    model = model.eval().cuda()
    model.set_chunk_size(chunk_size)
    
    # Lire le FASTA
    sequences = list(SeqIO.parse(fasta_file, "fasta"))
    print(f"Prédiction des structures pour {len(sequences)} protéines...")
    
    results = []
    for i, record in enumerate(sequences):
        seq = str(record.seq).upper()
        name = record.id
        
        print(f"[{i+1}/{len(sequences)}] Prédiction de {name} ({len(seq)} aa)...")
        
        try:
            with torch.no_grad():
                output = model.infer(seq)
                pdb = model.output_to_pdb(output)[0]
            
            plddt = output["plddt"].cpu().numpy()[0].mean()
            
            # Enregistrer le PDB
            output_path = os.path.join(output_dir, f"{name}.pdb")
            with open(output_path, "w") as f:
                f.write(pdb)
            
            results.append({
                "name": name,
                "length": len(seq),
                "mean_plddt": round(float(plddt), 2),
                "output": output_path,
                "status": "success"
            })
            
        except Exception as e:
            print(f"  Erreur : {e}")
            results.append({"name": name, "status": f"erreur : {e}"})
    
    # Écrire le résumé
    import csv
    with open(os.path.join(output_dir, "summary.csv"), "w") as f:
        writer = csv.DictWriter(f, fieldnames=["name", "length", "mean_plddt", "output", "status"])
        writer.writeheader()
        writer.writerows(results)
    
    success = sum(1 for r in results if r.get("status") == "success")
    print(f"\nTerminé ! {success}/{len(sequences)} structures prédictes avec succès")
    print(f"Résultats enregistrés dans {output_dir}/")

if __name__ == "__main__":
    predict_fasta(
        fasta_file="./proteins.fasta",
        output_dir="./predicted_structures",
        chunk_size=64
    )

---

Visualisation des structures

Avec Py3Dmol (Jupyter / Python)

import py3Dmol  # pip install py3Dmol

with open("protein.pdb") as f:
    pdb_data = f.read()

view = py3Dmol.view(width=800, height=600)
view.addModel(pdb_data, "pdb")
view.setStyle({"cartoon": {"colorscheme": "ssJmol"}})
view.zoomTo()
view.show()

Utiliser PyMOL

# Installer PyMOL
apt-get install pymol

# Ouvrir la structure
pymol lysozyme.pdb

Visualisation programmatique avec Biotite

import biotite.structure.io.pdb as pdb
import biotite.structure as struc
import numpy as np

# Charger la structure prédite
pdb_file = pdb.PDBFile.read("lysozyme.pdb")
structure = pdb.get_structure(pdb_file, model=1)

# Analyser la structure secondaire
sse = struc.annotate_sse(structure)

helix_frac = (sse == 'a').mean() * 100
sheet_frac = (sse == 'b').mean() * 100
coil_frac = (sse == 'c').mean() * 100

print(f"Composition de la structure secondaire :")
print(f"  Hélice alpha :  {helix_frac:.1f}%")
print(f"  Feuillet bêta :   {sheet_frac:.1f}%")
print(f"  Boucle/Autre :   {coil_frac:.1f}%")

---

Optimisation de la mémoire

Guide de taille de morceaux

# chunk_size plus faible = moins de VRAM, prédiction plus lente
# chunk_size plus élevé = plus de VRAM, prédiction plus rapide

# Pour 8 Go de VRAM (permet jusqu'à environ 400 aa)
model.set_chunk_size(32)

# Pour 16 Go de VRAM (jusqu'à environ 700 aa)
model.set_chunk_size(64)

# Pour 40 Go de VRAM (jusqu'à environ 2000 aa, sans découpage)
model.set_chunk_size(None)  # Désactiver le découpage

Déchargement sur CPU pour les séquences très longues

# Charger le modèle sur le CPU, le déplacer sur le GPU à chaque inférence
model = esm.pretrained.esmfold_v1()
model = model.eval()

# Déplacer sur le GPU pour l'inférence, puis revenir sur le CPU
model = model.cuda()
with torch.no_grad():
    output = model.infer(sequence)
model = model.cpu()  # Libérer la mémoire GPU
torch.cuda.empty_cache()

---

Dépannage

Mémoire CUDA insuffisante

# Réduire la taille des morceaux
model.set_chunk_size(32)  # ou même 16

# Vérifier la VRAM libre
nvidia-smi --query-gpu=memory.free --format=csv,noheader

# Pour les protéines très longues, les découper en domaines
# Il est généralement sûr de découper les protéines de plus de 1000 aa en domaines de 300 à 500 aa

ImportError pour openfold

# Réinstaller avec un commit spécifique
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Vérifier l'installation
python -c "import openfold; print('OpenFold OK')"

Chargement lent du modèle

# Le premier chargement télécharge 2,7 Go de poids du modèle — c’est normal
# Les chargements suivants utilisent des poids en cache (~30 s de temps de chargement)

# Vérifier l’emplacement du cache
python -c "import torch; print(torch.hub.get_dir())"
ls ~/.cache/torch/hub/

Remarque sur la mémoire : Le modèle de langage d’ESMFold (ESM-2, 15 milliards de paramètres) nécessite une quantité importante de VRAM. Pour les serveurs GPU disposant de moins de 16 Go de VRAM, utilisez la esm2_t33_650M_UR50D variante backbone ou activez un découpage agressif.

Interprétation du pLDDT :

• >90 = Confiance très élevée (bleu dans le code couleur d’AlphaFold)

• 70–90 = Confiant (cyan/bleu clair)

• 50–70 = Faible confiance (jaune) — à interpréter avec prudence

• <50 = Très faible confiance (orange/rouge) — région probablement désordonnée

---

Recommandations GPU Clore.ai

La mémoire VRAM requise par ESMFold est principalement déterminée par le modèle de langage ESM-2 à 15 milliards de paramètres. La longueur de la séquence ajoute une surcharge mémoire supplémentaire.

GPU	VRAM	Prix Clore.ai	Longueur maximale de séquence	Temps de prédiction (300 aa)
RTX 3090	24 Go	0,07–0,21 $/h	~400 aa (avec découpage)	~8 secondes
RTX 4090	24 Go	0,14–0,42 $/h	~400 aa (avec découpage)	~5 secondes
A100 40 Go	40 Go	bare metal	~800 aa sans difficulté	~3 secondes
A100 80 Go	80 Go	bare metal	~1 500+ aa, grandes protéines	~4 secondes

VRAM minimale : 16 Go. ESMFold ne peut pas fonctionner sur des GPU de 8 Go avec le backbone ESM-2 complet. Les RTX 3090/4090 (24 Go) peuvent traiter des protéines allant jusqu’à ~400 acides aminés sans découpage — activez chunk_size=64 dans l’API pour les séquences plus longues.

Meilleur rapport qualité-prix pour la recherche : La RTX 3090 à 0,07–0,21 $/h prend en charge la grande majorité des tâches de prédiction de structure protéique (protéine humaine moyenne : ~300–400 aa). À ~8 secondes par prédiction, vous pouvez traiter ~450 structures par heure pour un total d’environ 0,12 $ — contre AlphaFold2, qui nécessite un calcul MSA prenant des minutes par structure.

Protéomique à haut débit : Pour cribler des milliers de séquences, l’A100 40 Go (bare metal)

---

Ressources

• 🐙 GitHub : github.com/facebookresearch/esm

• 🤗 Modèles : huggingface.co/facebook/esmfold_v1

• 📄 Article : Prédiction à l’échelle évolutive de la structure protéique au niveau atomique avec un modèle de langage (Science, 2023)

• 🌐 Atlas métagénomique ESM : esmatlas.com — 772 millions de structures prédites avec ESMFold

• 💻 Blog Meta AI : ai.meta.com/blog/protein-folding-esmfold-metagenomics

• 🔬 Journal des modifications ESM : github.com/facebookresearch/esm/blob/main/CHANGELOG.md