Structure protéique ESMFold

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

🧬 Développé par Meta AI Research | Licence MIT | 10x–60x 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 protéique au monde (15 milliards de paramètres) — pour prédire des structures protéiques 3D directement à partir de séquences d'acides aminés.

Avantages clés par rapport à AlphaFold2

Fonctionnalité

ESMFold

AlphaFold2

MSA requis

❌ Non

✅ Oui

Vitesse (protéine typique)

~2 secondes

~10 minutes–heures

Précision (score TM)

~0.87

~0.92

VRAM GPU (650 aa)

~8GB

Entrée séquence unique

✅ Oui

Limité

Protéines orphelines

✅ Excellent

A des difficultés

Pourquoi pas de MSA ?

AlphaFold2 nécessite Alignement de séquences multiples (MSA) — collecter et aligner les parents évolutifs de la protéine requête. Cela est coûteux en calcul et impossible pour des protéines nouvelles ou conçues sans parents é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 entièrement le MSA. Cela le rend :

Plus rapide : Pas de recherche MSA (minutes économisées par prédiction)
Plus évolutif : Traiter efficacement des protéomes entiers
Mieux pour les protéines nouvelles : Les séquences conçues n'ont pas de parents évolutifs

Démarrage rapide sur Clore.ai

Étape 1 : Choisir 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 40GB, RTX 3090, RTX 4090 pour le modèle complet
Option plus petite : Utilisez esm2_t33_650M_UR50D pour 8GB de VRAM

Guide VRAM GPU :

Longueur de la protéine

Variante du modèle

VRAM requise

Jusqu'à 300 aa

ESMFold (3B)

~16GB

Jusqu'à 500 aa

ESMFold (3B)

~20GB

Jusqu'à 1000 aa

ESMFold (3B)

~40GB

Jusqu'à 600 aa

ESMFold (chunk)

~8GB

Étape 2 : Construire une image Docker personnalisée

FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-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 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éployer sur Clore.ai

Image Docker : yourname/esmfold:latest
Ports : 22 (SSH)
Environnement : NVIDIA_VISIBLE_DEVICES=all

Installation et configuration

Méthode 1 : pip install

# Installer ESMFold
pip install fair-esm[esmfold]

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

# Optionnel 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 d'ESM :", esm.__version__)

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

Utilisation basique

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()

# Optionnel : Activer la taille de chunk pour économiser de 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)

# Sauvegarder 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 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_par_residu = plddt[0]

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

# Classer les régions de confiance
for i, score in enumerate(plddt_par_residu):
    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 sortie complète

Serveur 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 ~30 secondes)...")
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()
model.set_chunk_size(64)  # Optimisation 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 protéique 3D à partir d'une 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 standards."
        )
    
    if len(sequence) > 2000:
        raise HTTPException(
            status_code=400,
            detail="Séquence trop longue (max 2000 acides aminés). Pour des séquences plus longues, utilisez la 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="GPU hors mémoire. 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 des structures, /docs pour l'interface Swagger"}

# Lancer 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\"Name: {data['name']}\")
print(f\"Length: {data['sequence_length']} aa\")
print(f\"pLDDT moyen : {data['mean_plddt']:.1f}\")
print(f\"Temps : {data['inference_time_seconds']}s\")
# Sauvegarder 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 les 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()
            
            # Sauvegarder 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"error: {e}"})
    
    # Écrire le récapitulatif
    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édites 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

Utilisation de 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()

Utilisation de 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 chunk

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

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

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

# Pour 40GB de VRAM (jusqu'à ~2000 aa, pas de chunking)
model.set_chunk_size(None)  # Désactiver le chunking

Déchargement CPU pour des séquences très longues

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

# Déplacer sur GPU pour l'inférence, revenir sur CPU après
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

CUDA : mémoire insuffisante

# Réduire la taille des chunks
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, diviser en domaines
# Il est généralement sûr de diviser les protéines > 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 des poids de modèle de 2,7 Go — c'est normal
# Les chargements suivants utilisent les poids en cache (~30s de temps de chargement)

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

Remarque mémoire : Le modèle de langage d'ESMFold (ESM-2 15B paramètres) requiert une VRAM significative. Pour des serveurs GPU avec moins de 16GB de VRAM, utilisez la esm2_t33_650M_UR50D variante backbone ou activez un chunking agressif.

Interprétation du pLDDT :

>90 = Confiance très élevée (bleu dans le coloriage AlphaFold)
70–90 = Confiant (cyan/bleu clair)
50–70 = Faible confiance (jaune) — traiter avec prudence
<50 = Très faible confiance (orange/rouge) — région probablement désordonnée

Recommandations GPU Clore.ai

La demande en VRAM d'ESMFold est dominée par le modèle de langage ESM-2 à 15 milliards de paramètres. La longueur de la séquence ajoute un surcoût mémoire.

GPU

VRAM

Prix Clore.ai

Longueur maximale de séquence

Temps de prédiction (300 aa)

RTX 3090

24 Go

~0,12 $/h

~400 aa (avec chunking)

~8 secondes

RTX 4090

24 Go

~0,70 $/h

~400 aa (avec chunking)

~5 secondes

A100 40GB

40 Go

~1,20 $/h

~800 aa confortablement

~3 secondes

A100 80GB

80 Go

~2,00 $/h

~1500+ aa, grosses protéines

~4 secondes

VRAM minimale : 16GB. ESMFold ne peut pas fonctionner sur des GPUs de 8GB avec le backbone ESM-2 complet. Le RTX 3090/4090 (24GB) peut gérer des protéines jusqu'à ~400 acides aminés sans chunking — activez chunk_size=64 dans l'API pour des séquences plus longues.

Meilleur rapport qualité/prix pour la recherche : Le RTX 3090 à ~0,12 $/h gère 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 ~0,12 $ au total — comparé à AlphaFold2 qui nécessite un calcul MSA prenant des minutes par structure.

Protéomique à haut débit : Pour le criblage de milliers de séquences, un A100 40GB (~1,20 $/h) avec inférence en lot traite ~1 200+ prédictions par heure — viable pour des études à l'échelle des protéomes.

Ressources

🐙 GitHub : github.com/facebookresearch/esm
🤗 Modèles : huggingface.co/facebook/esmfold_v1
📄 Article : Prediction à 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 — 772M 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

PrécédentPrédiction de protéines AlphaFold2 SuivantDynamique moléculaire GROMACS

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagQu'est-ce qu'ESMFold ?

hashtagAvantages clés par rapport à AlphaFold2

hashtagPourquoi pas de MSA ?

hashtagDémarrage rapide sur Clore.ai

hashtagÉtape 1 : Choisir un serveur

hashtagÉtape 2 : Construire une image Docker personnalisée

hashtagÉtape 3 : Déployer sur Clore.ai

hashtagInstallation et configuration

hashtagMéthode 1 : pip install

hashtagMéthode 2 : Depuis les sources

hashtagVérifier l'installation

hashtagUtilisation basique

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

hashtagPrédire plusieurs séquences (lot)

hashtagObtenir la confiance par résidu (pLDDT)

hashtagServeur API REST

hashtagExemples d'utilisation de l'API

hashtagScript de traitement par lot

hashtagVisualisation des structures

hashtagUtilisation de Py3Dmol (Jupyter / Python)

hashtagUtilisation de PyMOL

hashtagVisualisation programmatique avec Biotite

hashtagOptimisation de la mémoire

hashtagGuide de taille de chunk

hashtagDéchargement CPU pour des séquences très longues

hashtagDépannage

hashtagCUDA : mémoire insuffisante

hashtagImportError pour openfold

hashtagChargement lent du modèle

hashtagRecommandations GPU Clore.ai

hashtagRessources

Qu'est-ce qu'ESMFold ?

Avantages clés par rapport à AlphaFold2

Pourquoi pas de MSA ?

Démarrage rapide sur Clore.ai

Étape 1 : Choisir un serveur

Étape 2 : Construire une image Docker personnalisée

Étape 3 : Déployer sur Clore.ai

Installation et configuration

Méthode 1 : pip install

Méthode 2 : Depuis les sources

Vérifier l'installation

Utilisation basique

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

Prédire plusieurs séquences (lot)

Obtenir la confiance par résidu (pLDDT)

Serveur API REST

Exemples d'utilisation de l'API

Script de traitement par lot

Visualisation des structures

Utilisation de Py3Dmol (Jupyter / Python)

Utilisation de PyMOL

Visualisation programmatique avec Biotite

Optimisation de la mémoire

Guide de taille de chunk

Déchargement CPU pour des séquences très longues

Dépannage

CUDA : mémoire insuffisante

ImportError pour openfold

Chargement lent du modèle

Recommandations GPU Clore.ai

Ressources