Estructura de proteínas ESMFold

Predicción ultrarrápida de estructuras proteicas por Meta AI — predecir estructuras proteicas 3D a partir de secuencias de aminoácidos en segundos, sin alineamientos múltiples de secuencias.

🧬 Desarrollado por Meta AI Research | Licencia MIT | 10x–60x más rápido que AlphaFold2

---

¿Qué es ESMFold?

ESMFold es el sistema de predicción de estructuras proteicas de Meta AI que aprovecha Evolutionary Scale Modeling (ESM-2) — el modelo de lenguaje de proteínas más grande del mundo (15 mil millones de parámetros) — para predecir estructuras proteicas 3D directamente a partir de secuencias de aminoácidos.

Ventajas clave frente a AlphaFold2

Característica	ESMFold	AlphaFold2
¿Se requiere MSA?	❌ No	✅ Sí
Velocidad (proteína típica)	~2 segundos	~10 min–horas
Precisión (TM-score)	~0.87	~0.92
VRAM de GPU (650 aa)	~8GB	~8GB
Entrada de secuencia única	✅ Sí	Limitado
Proteínas huérfanas	✅ Excelente	Dificultades

¿Por qué sin MSA?

AlphaFold2 requiere Alineamiento Múltiple de Secuencias (MSA) — recopilar y alinear parientes evolutivos de la proteína consulta. Esto es computacionalmente costoso e imposible para proteínas novedosas o diseñadas sin parientes evolutivos.

ESMFold almacena información evolutiva en los pesos de su modelo de lenguaje (entrenado con 250 millones de secuencias proteicas), eliminando completamente el MSA. Esto lo hace:

• Más rápido: Sin búsqueda MSA (minutos ahorrados por predicción)

• Más escalable: Procesar proteomas completos eficientemente

• Mejor para proteínas novedosas: Las secuencias diseñadas no tienen parientes evolutivos

---

Inicio rápido en Clore.ai

Paso 1: Seleccione un servidor

En clore.ai mercado:

• Mínimo: GPU NVIDIA con 16GB de VRAM (el modelo de lenguaje ESM-2 es grande)

• Recomendado: A100 40GB, RTX 3090, RTX 4090 para el modelo completo

• Opción más pequeña: Usa esm2_t33_650M_UR50D para 8GB de VRAM

Guía de VRAM de GPU:

Longitud de la proteína	Variante del modelo	VRAM requerida
Hasta 300 aa	ESMFold (3B)	~16GB
Hasta 500 aa	ESMFold (3B)	~20GB
Hasta 1000 aa	ESMFold (3B)	~40GB
Hasta 600 aa	ESMFold (chunk)	~8GB

Paso 2: Construir imagen Docker personalizada

FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-devel

# Dependencias del sistema
RUN apt-get update && apt-get install -y \
    git \
    wget \
    curl \
    openssh-server \
    libhdf5-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

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

# Instalar ESMFold y dependencias
RUN pip install --no-cache-dir \
    fair-esm[esmfold] \
    torch \
    biopython \
    biotite \
    fastapi \
    uvicorn \
    pydantic \
    openmm==8.0.0 \
    pdbfixer

# Instalar OpenFold (requerido para ESMFold)
RUN pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

EXPOSE 22

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

Paso 3: Desplegar en Clore.ai

• Imagen Docker: yourname/esmfold:latest

• Puertos: 22 (SSH)

• Entorno: NVIDIA_VISIBLE_DEVICES=all

---

Instalación y configuración

Método 1: pip install

# Instalar ESMFold
pip install fair-esm[esmfold]

# Instalar OpenFold (dependencia requerida)
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Opcional pero recomendado
pip install biotite biopython

Método 2: Desde el código fuente

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

Verificar la instalación

import esm
print("Versión de ESM:", esm.__version__)

# Prueba rápida de carga del modelo
model = esm.pretrained.esmfold_v1()
print("¡ESMFold cargado con éxito!")

---

Uso básico

Predecir la estructura de una sola proteína

import torch
import esm

# Cargar el modelo ESMFold
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()

# Opcional: Habilitar tamaño de chunk para ahorrar VRAM
# Aumenta el tiempo de cómputo pero reduce el uso de VRAM
model.set_chunk_size(64)  # Reducir para menos VRAM

# Secuencia de proteína (ejemplo: Lisocima C)
sequence = "KVFGRCELAAAMKRHGLDNYRGYSLGNWVCAAKFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSALLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL"

# Predecir estructura
with torch.no_grad():
    output = model.infer_pdb(sequence)

# Guardar archivo PDB
with open("lysozyme.pdb", "w") as f:
    f.write(output)

print(f"¡Estructura predicha! Guardada en lysozyme.pdb")
print(f"Longitud de la secuencia: {len(sequence)} aminoácidos")

Predecir múltiples secuencias (lote)

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"Predicho {name}: {len(seq)} aa")

print("¡Todas las predicciones completadas!")

Obtener confianza por residuo (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)

# Extraer puntuaciones pLDDT (confianza por residuo)
plddt = output["plddt"].cpu().numpy()  # Forma: [1, seq_len]
plddt_per_residue = plddt[0]

print(f"pLDDT medio: {plddt_per_residue.mean():.2f}")
print(f"Residuos con alta confianza (>90): {(plddt_per_residue > 90).sum()}")
print(f"Residuos con baja confianza (<50): {(plddt_per_residue < 50).sum()}")

# Clasificar regiones por confianza
for i, score in enumerate(plddt_per_residue):
    if score >= 90:
        confidence = "Muy alta (azul)"
    elif score >= 70:
        confidence = "Confiable (azul claro)"
    elif score >= 50:
        confidence = "Baja (amarillo)"
    else:
        confidence = "Muy baja (naranja)"
    # print(f"Residuo {i+1}: {score:.1f} - {confidence}")  # Descomentar para salida completa

---

Servidor REST API

Construir una API de producción para 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="ESMFold Protein Structure Prediction API",
    description="Predecir estructuras 3D de proteínas a partir de secuencias de aminoácidos",
    version="1.0.0"
)

# Cargar modelo al iniciar
print("Cargando el modelo ESMFold (esto toma ~30 segundos)...")
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()
model.set_chunk_size(64)  # Optimización de memoria
print("¡ESMFold listo!")

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):
    """Predecir la estructura 3D de una proteína a partir de la secuencia de aminoácidos."""
    
    # Validar secuencia
    valid_aa = set("ACDEFGHIKLMNPQRSTVWY")
    sequence = request.sequence.upper().strip()
    
    invalid = set(sequence) - valid_aa
    if invalid:
        raise HTTPException(
            status_code=400,
            detail=f"Aminoácidos inválidos en la secuencia: {invalid}. Use los 20 aminoácidos estándar."
        )
    
    if len(sequence) > 2000:
        raise HTTPException(
            status_code=400,
            detail="Secuencia demasiado larga (máx. 2000 aminoácidos). Para secuencias más largas, use predicción en fragmentos."
        )
    
    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 sin memoria. Intente una secuencia más corta o reduzca el tamaño de chunk."
        )
    
    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": "ESMFold API — /predict para predecir estructuras, /docs para Swagger UI"}

# Ejecutar la API
pip install fastapi uvicorn
uvicorn api_server:app --host 0.0.0.0 --port 8080 --workers 1

---

Ejemplos de uso de la API

# Predecir estructura vía API
curl -X POST http://localhost:8080/predict \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ubiquitina",
    "sequence": "MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG"
  }' | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(f\"Nombre: {data['name']}\")
print(f\"Longitud: {data['sequence_length']} aa\")
print(f\"pLDDT medio: {data['mean_plddt']:.1f}\")
print(f\"Tiempo: {data['inference_time_seconds']}s\")
# Guardar PDB
open('ubiquitin.pdb', 'w').write(data['pdb_content'])
print('¡PDB guardado!')
"

---

Script de procesamiento por lotes

# 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):
    """Predecir estructuras para todas las secuencias en un archivo FASTA."""
    
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # Cargar modelo
    model = esm.pretrained.esmfold_v1()
    model = model.eval().cuda()
    model.set_chunk_size(chunk_size)
    
    # Leer FASTA
    sequences = list(SeqIO.parse(fasta_file, "fasta"))
    print(f"Prediciendo estructuras para {len(sequences)} proteínas...")
    
    results = []
    for i, record in enumerate(sequences):
        seq = str(record.seq).upper()
        name = record.id
        
        print(f"[{i+1}/{len(sequences)}] Prediciendo {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()
            
            # Guardar 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"  Error: {e}")
            results.append({"name": name, "status": f"error: {e}"})
    
    # Escribir resumen
    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"\n¡Hecho! {success}/{len(sequences)} estructuras predichas con éxito")
    print(f"Resultados guardados en {output_dir}/")

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

---

Visualización de estructuras

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

Usando PyMOL

# Instalar PyMOL
apt-get install pymol

# Abrir estructura
pymol lysozyme.pdb

Visualización programática con Biotite

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

# Cargar estructura predicha
pdb_file = pdb.PDBFile.read("lysozyme.pdb")
structure = pdb.get_structure(pdb_file, model=1)

# Analizar estructura secundaria
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"Composición de estructura secundaria:")
print(f"  Hélice alfa:  {helix_frac:.1f}%")
print(f"  Hoja beta:    {sheet_frac:.1f}%")
print(f"  Coil/Otro:    {coil_frac:.1f}%")

---

Optimización de memoria

Guía de tamaño de chunk

# Menor chunk_size = menos VRAM, predicción más lenta
# Mayor chunk_size = más VRAM, predicción más rápida

# Para 8GB de VRAM (permite hasta ~400 aa)
model.set_chunk_size(32)

# Para 16GB de VRAM (hasta ~700 aa)
model.set_chunk_size(64)

# Para 40GB de VRAM (hasta ~2000 aa, sin chunking)
model.set_chunk_size(None)  # Desactivar chunking

Descarga a CPU para secuencias muy largas

# Cargar modelo en CPU, mover a GPU por inferencia
model = esm.pretrained.esmfold_v1()
model = model.eval()

# Mover a GPU para inferencia, volver a CPU después
model = model.cuda()
with torch.no_grad():
    output = model.infer(sequence)
model = model.cpu()  # Liberar memoria GPU
torch.cuda.empty_cache()

---

Solución de problemas

CUDA Fuera de memoria

# Reducir tamaño de chunk
model.set_chunk_size(32)  # o incluso 16

# Comprobar VRAM libre
nvidia-smi --query-gpu=memory.free --format=csv,noheader

# Para proteínas muy largas, dividir en dominios
# Normalmente seguro dividir proteínas > 1000 aa en dominios de 300-500 aa

ImportError para openfold

# Reinstalar con commit específico
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Comprobar la instalación
python -c "import openfold; print('OpenFold OK')"

Carga lenta del modelo

# La primera carga descarga pesos del modelo de 2.7GB — esto es normal
# Cargas posteriores usan pesos en caché (~30s de tiempo de carga)

# Comprobar ubicación de la caché
python -c "import torch; print(torch.hub.get_dir())"
ls ~/.cache/torch/hub/

Nota sobre memoria: El modelo de lenguaje de ESMFold (ESM-2 de 15B parámetros) requiere VRAM significativa. Para servidores GPU con menos de 16GB de VRAM, use la esm2_t33_650M_UR50D variante backbone o habilite un chunking agresivo.

Interpretación de pLDDT:

• >90 = Confianza muy alta (azul en la coloración de AlphaFold)

• 70–90 = Confiable (cian/azul claro)

• 50–70 = Baja confianza (amarillo) — trate con precaución

• <50 = Muy baja confianza (naranja/rojo) — probablemente región desordenada

---

Recomendaciones de GPU en Clore.ai

El requisito de VRAM de ESMFold está dominado por el modelo de lenguaje ESM-2 de 15B parámetros. La longitud de la secuencia añade sobrecarga de memoria adicional.

GPU	VRAM	Precio en Clore.ai	Longitud máxima de secuencia	Tiempo de predicción (300 aa)
RTX 3090	24 GB	~$0.12/h	~400 aa (con chunking)	~8 segundos
RTX 4090	24 GB	~$0.70/h	~400 aa (con chunking)	~5 segundos
A100 40GB	40 GB	~$1.20/h	~800 aa cómodamente	~3 segundos
A100 80GB	80 GB	~$2.00/h	~1500+ aa, proteínas grandes	~4 segundos

VRAM mínima: 16GB. ESMFold no puede ejecutarse en GPUs de 8GB con el backbone ESM-2 completo. La RTX 3090/4090 (24GB) puede manejar proteínas de hasta ~400 aminoácidos sin chunking — habilite chunk_size=64 en la API para secuencias más largas.

Mejor relación calidad-precio para investigación: La RTX 3090 a ~$0.12/h maneja la gran mayoría de tareas de predicción de estructuras proteicas (proteína humana promedio: ~300–400 aa). A ~8 segundos por predicción, puede procesar ~450 estructuras por hora por ~$0.12 en total — en comparación con AlphaFold2 que requiere cálculo de MSA que toma minutos por estructura.

Proteómica de alto rendimiento: Para cribar miles de secuencias, A100 40GB (~$1.20/h) con inferencia por lotes procesa ~1,200+ predicciones por hora — viable para estudios a escala de proteomas.

---

Recursos

• 🐙 GitHub: github.com/facebookresearch/esm

• 🤗 Modelos: huggingface.co/facebook/esmfold_v1

• 📄 Artículo: Predicción a escala evolutiva de la estructura proteica a nivel atómico con un modelo de lenguaje (Science, 2023)

• 🌐 Atlas metagenómico ESM: esmatlas.com — 772M de estructuras predichas con ESMFold

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

• 🔬 Registro de cambios de ESM: github.com/facebookresearch/esm/blob/main/CHANGELOG.md