Структура белка ESMFold

Ультрабыстрое предсказание структуры белка от Meta AI — предсказывайте 3D-структуры белков по последовательностям аминокислот за секунды, без множественных выравниваний последовательностей.

🧬 Разработано Meta AI Research | Лицензия MIT | в 10–60 раз быстрее AlphaFold2

---

Что такое ESMFold?

ESMFold — это система Meta AI для предсказания структуры белков, которая использует Evolutionary Scale Modeling (ESM-2) — крупнейшую в мире языковую модель для белков (15 миллиардов параметров) — для прямого предсказания 3D-структур белков по последовательностям аминокислот.

Ключевые преимущества по сравнению с AlphaFold2

Функция	ESMFold	AlphaFold2
Требуется MSA	❌ Нет	✅ Да
Скорость (типичный белок)	~2 секунды	~10 мин–часы
Точность (TM-score)	~0.87	~0.92
GPU VRAM (650 а. к.)	~8 ГБ	~8 ГБ
Ввод одной последовательности	✅ Да	Ограниченная
Сиротские белки	✅ Отлично	Испытывает трудности

Почему без MSA?

AlphaFold2 требует множественного выравнивания последовательностей (MSA) — сбора и выравнивания эволюционных родственников белка-запроса. Это вычислительно дорого и невозможно для новых или искусственно созданных белков, у которых нет эволюционных родственников.

ESMFold хранит эволюционную информацию в весах своей языковой модели (обученной на 250 миллионах белковых последовательностей), полностью исключая необходимость MSA. Это делает его:

• Быстрее: Без поиска MSA (экономия минут на каждом предсказании)

• Более масштабируемым: Эффективно обрабатывайте целые протеомы

• Лучше для новых белков: Искусственно созданные последовательности не имеют эволюционных родственников

---

Быстрый старт на Clore.ai

Шаг 1: Выберите сервер

На маркетплейсе clore.ai маркетплейс:

• Минимум: NVIDIA GPU с 16 ГБ VRAM (языковая модель ESM-2 очень большая)

• Рекомендуется: A100 40GB, RTX 3090, RTX 4090 для полной модели

• Меньший вариант: Используйте esm2_t33_650M_UR50D для 8 ГБ VRAM

Руководство по VRAM GPU:

Длина белка	Вариант модели	Требуемая VRAM
До 300 а. к.	ESMFold (3B)	~16 ГБ
До 500 а. к.	ESMFold (3B)	~20 ГБ
До 1000 а. к.	ESMFold (3B)	~40 ГБ
До 600 а. к.	ESMFold (chunk)	~8 ГБ

Шаг 2: Соберите собственный Docker-образ

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

# Системные зависимости
RUN apt-get update && apt-get install -y \\
    git \\
    wget \\
    curl \\
    openssh-server \\
    libhdf5-dev \\
    pkg-config \\
    && rm -rf /var/lib/apt/lists/*

# Настройка SSH
RUN mkdir /var/run/sshd && \\
    echo 'root:esmfold' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Установите ESMFold и зависимости
RUN pip install --no-cache-dir \
    fair-esm[esmfold] \\
    torch \\
    biopython \\
    biotite \\
    fastapi \\
    uvicorn \\
    pydantic \\
    openmm==8.0.0 \\
    pdbfixer

# Установите OpenFold (требуется для ESMFold)
RUN pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

EXPOSE 22

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

Шаг 3: разверните на Clore.ai

• Docker-образ: yourname/esmfold:latest

• Порты: 22 (SSH)

• Окружение: NVIDIA_VISIBLE_DEVICES=all

---

Установка и настройка

Способ 1: pip install

# Установите ESMFold
pip install fair-esm[esmfold]

# Установите OpenFold (обязательная зависимость)
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Необязательно, но рекомендуется
pip install biotite biopython

Способ 2: из исходников

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

Проверка установки

import esm
print("Версия ESM:", esm.__version__)

# Быстрый тест загрузки модели
model = esm.pretrained.esmfold_v1()
print("ESMFold успешно загружен!")

---

Базовое использование

Предсказать структуру одного белка

import torch
import esm

# Загрузите модель ESMFold
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()

# Необязательно: включите размер чанка для экономии VRAM
# Увеличивает время вычислений, но снижает использование VRAM
model.set_chunk_size(64)  # Уменьшите для меньшего расхода VRAM

# Последовательность белка (пример: лизоцим C)
sequence = "KVFGRCELAAAMKRHGLDNYRGYSLGNWVCAAKFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSALLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL"

# Предсказать структуру
with torch.no_grad():
    output = model.infer_pdb(sequence)

# Сохранить PDB-файл
with open("lysozyme.pdb", "w") as f:
    f.write(output)

print(f"Структура предсказана! Сохранено в lysozyme.pdb")
print(f"Длина последовательности: {len(sequence)} аминокислот")

Предсказать несколько последовательностей (пакетно)

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"Предсказан {name}: {len(seq)} а. к.")

print("Все предсказания завершены!")

Получить доверие по каждому остатку (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)

# Извлечь оценки pLDDT (доверие по каждому остатку)
plddt = output["plddt"].cpu().numpy()  # Форма: [1, seq_len]
plddt_per_residue = plddt[0]

print(f"Средний pLDDT: {plddt_per_residue.mean():.2f}")
print(f"Остатков с высокой уверенностью (>90): {(plddt_per_residue > 90).sum()}")
print(f"Остатков с низкой уверенностью (<50): {(plddt_per_residue < 50).sum()}")

# Классифицировать области по уверенности
for i, score in enumerate(plddt_per_residue):
    if score >= 90:
        confidence = "Очень высокая (синий)"
    elif score >= 70:
        confidence = "Уверенная (светло-синий)"
    elif score >= 50:
        confidence = "Низкая (жёлтый)"
    else:
        confidence = "Очень низкая (оранжевый)"
    # print(f"Остаток {i+1}: {score:.1f} - {confidence}")  # Раскомментируйте для полного вывода

---

Сервер REST API

Создайте production API для 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 для предсказания структуры белка ESMFold",
        description="Предсказание 3D-структур белков по последовательностям аминокислот",
    version="1.0.0"
)

# Загрузить модель при запуске
print("Загрузка модели ESMFold (это занимает ~30 секунд)...")
model = esm.pretrained.esmfold_v1()
model = model.eval().cuda()
model.set_chunk_size(64)  # Оптимизация памяти
print("ESMFold готов!")

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):
    """Предсказать 3D-структуру белка по последовательности аминокислот."""
    
    # Проверить последовательность
    valid_aa = set("ACDEFGHIKLMNPQRSTVWY")
    sequence = request.sequence.upper().strip()
    
    invalid = set(sequence) - valid_aa
    if invalid:
        raise HTTPException(
            status_code=400,
            detail=f"Недопустимые аминокислоты в последовательности: {invalid}. Используйте стандартные 20 аминокислот."
        )
    
    if len(sequence) > 2000:
        raise HTTPException(
            status_code=400,
            detail="Последовательность слишком длинная (максимум 2000 аминокислот). Для более длинных последовательностей используйте предсказание с чанками."
        )
    
    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 недостаточно памяти. Попробуйте более короткую последовательность или уменьшите размер чанка."
        )
    
    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 для предсказания структур, /docs для Swagger UI"}

# Запустить API
pip install fastapi uvicorn
uvicorn api_server:app --host 0.0.0.0 --port 8080 --workers 1

---

Примеры использования API

# Предсказать структуру через 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\"Имя: {data['name']}\")
print(f\"Длина: {data['sequence_length']} а. к.\")
print(f\"Средний pLDDT: {data['mean_plddt']:.1f}\")
print(f\"Время: {data['inference_time_seconds']}с\")
# Сохранить PDB
open('ubiquitin.pdb', 'w').write(data['pdb_content'])
print('PDB сохранён!')
"

---

Скрипт пакетной обработки

# 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):
    """Предсказать структуры для всех последовательностей в FASTA-файле."""
    
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # Загрузить модель
    model = esm.pretrained.esmfold_v1()
    model = model.eval().cuda()
    model.set_chunk_size(chunk_size)
    
    # Прочитать FASTA
    sequences = list(SeqIO.parse(fasta_file, "fasta"))
    print(f"Предсказание структур для {len(sequences)} белков...")
    
    results = []
    for i, record in enumerate(sequences):
        seq = str(record.seq).upper()
        name = record.id
        
        print(f"[{i+1}/{len(sequences)}] Предсказание {name} ({len(seq)} а. к.)...")
        
        try:
            with torch.no_grad():
                output = model.infer(seq)
                pdb = model.output_to_pdb(output)[0]
            
            plddt = output["plddt"].cpu().numpy()[0].mean()
            
            # Сохранить 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"  Ошибка: {e}")
            results.append({"name": name, "status": f"error: {e}"})
    
    # Записать сводку
    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Готово! Успешно предсказано структур: {success}/{len(sequences)}")
    print(f"Результаты сохранены в {output_dir}/")

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

---

Визуализация структур

С помощью 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()

С помощью PyMOL

# Установите PyMOL
apt-get install pymol

# Открыть структуру
pymol lysozyme.pdb

Программная визуализация с Biotite

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

# Загрузить предсказанную структуру
pdb_file = pdb.PDBFile.read("lysozyme.pdb")
structure = pdb.get_structure(pdb_file, model=1)

# Анализировать вторичную структуру
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"Состав вторичной структуры:")
print(f"  Альфа-спираль:  {helix_frac:.1f}%")
print(f"  Бета-слой:      {sheet_frac:.1f}%")
print(f"  Петля/прочее:   {coil_frac:.1f}%")

---

Оптимизация памяти

Руководство по размеру чанка

# Меньший chunk_size = меньше VRAM, медленнее предсказание
# Больший chunk_size = больше VRAM, быстрее предсказание

# Для 8 ГБ VRAM (позволяет до ~400 а. к.)
model.set_chunk_size(32)

# Для 16 ГБ VRAM (до ~700 а. к.)
model.set_chunk_size(64)

# Для 40 ГБ VRAM (до ~2000 а. к., без чанкинга)
model.set_chunk_size(None)  # Отключить чанкинг

Выгрузка на CPU для очень длинных последовательностей

# Загрузить модель на CPU, переносить на GPU на время инференса
model = esm.pretrained.esmfold_v1()
model = model.eval()

# Перенести на GPU для инференса, затем обратно на CPU
model = model.cuda()
with torch.no_grad():
    output = model.infer(sequence)
model = model.cpu()  # Освободить память GPU
torch.cuda.empty_cache()

---

Устранение неполадок

Недостаточно памяти CUDA

# Уменьшить размер чанка
model.set_chunk_size(32)  # или даже 16

# Проверить свободную VRAM
nvidia-smi --query-gpu=memory.free --format=csv,noheader

# Для очень длинных белков разделяйте их на домены
# Обычно безопасно разделять белки длиной > 1000 а. к. на домены по 300–500 а. к.

ImportError для openfold

# Переустановите с конкретным коммитом
pip install "git+https://github.com/aqlaboratory/openfold.git@4b41059694619831a7db195b7e0988fc4ff3a307"

# Проверить установку
python -c "import openfold; print('OpenFold OK')"

Медленная загрузка модели

# При первой загрузке скачиваются веса модели объёмом 2,7 ГБ — это нормально
# Последующие загрузки используют кэшированные веса (время загрузки ~30 с)

# Проверьте расположение кэша
python -c "import torch; print(torch.hub.get_dir())"
ls ~/.cache/torch/hub/

Примечание по памяти: Языковая модель ESMFold (ESM-2 с 15 млрд параметров) требует значительного объёма видеопамяти. Для GPU-серверов с менее чем 16 ГБ VRAM используйте esm2_t33_650M_UR50D вариант backbone или включите агрессивное чанкирование.

Интерпретация pLDDT:

• >90 = Очень высокая уверенность (синий в раскраске AlphaFold)

• 70–90 = Уверенно (голубой/светло-синий)

• 50–70 = Низкая уверенность (жёлтый) — следует интерпретировать с осторожностью

• <50 = Очень низкая уверенность (оранжевый/красный) — вероятно, неупорядоченный участок

---

Рекомендации по GPU для Clore.ai

Требование ESMFold к VRAM в основном определяется языковой моделью ESM-2 с 15 млрд параметров. Длина последовательности добавляет дополнительную нагрузку на память.

GPU	VRAM	Цена Clore.ai	Максимальная длина последовательности	Время предсказания (300 аминокислот)
RTX 3090	24 ГБ	$0.07–0.21/ч	~400 а. о. (с разбиением на чанки)	~8 секунд
RTX 4090	24 ГБ	$0.14–0.42/ч	~400 а. о. (с разбиением на чанки)	~5 секунд
A100 40 ГБ	40 ГБ	голое железо	~800 а. о. без проблем	~3 секунды
A100 80 ГБ	80 ГБ	голое железо	~1500+ а. о., крупные белки	~4 секунды

Минимальная VRAM: 16 ГБ. ESMFold не может работать на GPU с 8 ГБ с полным backbone ESM-2. RTX 3090/4090 (24 ГБ) могут обрабатывать белки длиной до ~400 аминокислот без чанкинга — включите chunk_size=64 в API для более длинных последовательностей.

Лучшее соотношение цены и качества для исследований: RTX 3090 за $0.07–0.21/час справляется с подавляющим большинством задач по предсказанию структуры белков (средний человеческий белок: ~300–400 а. о.). При ~8 секундах на предсказание вы можете обрабатывать ~450 структур в час всего за ~$0.12 — по сравнению с AlphaFold2, которому требуется вычисление MSA, занимающее минуты на структуру.

Высокопроизводительная протеомика: Для скрининга тысяч последовательностей A100 40GB (голое железо) с пакетным выводом обрабатывает ~1,200+ предсказаний в час — подходит для исследований на масштабе протеома.

---

Ресурсы

• 🐙 GitHub: github.com/facebookresearch/esm

• 🤗 Модели: huggingface.co/facebook/esmfold_v1

• 📄 Статья: Предсказание структуры белка на атомном уровне в эволюционном масштабе с помощью языковой модели (Science, 2023)

• 🌐 ESM Metagenomic Atlas: esmatlas.com — предсказано 772 млн структур с помощью ESMFold

• 💻 Блог Meta AI: ai.meta.com/blog/protein-folding-esmfold-metagenomics

• 🔬 Журнал изменений ESM: github.com/facebookresearch/esm/blob/main/CHANGELOG.md