> 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-ru/nauka-i-issledovaniya/esmfold.md).

# Структура белка 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](https://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-образ

```dockerfile
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

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

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

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

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

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

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

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

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

***

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

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

```python
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)} аминокислот")
```

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

```python
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)

```python
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:

```python
# 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"}
```

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

***

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

```bash
# Предсказать структуру через 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 сохранён!')
"
```

***

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

```python
# 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)

```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

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

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

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

```python
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}%")
```

***

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

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

```python
# Меньший 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 для очень длинных последовательностей

```python
# Загрузить модель на 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

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

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

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

### ImportError для openfold

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

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

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

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

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

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

{% hint style="info" %}
**Интерпретация pLDDT:**

* **>90** = Очень высокая уверенность (синий в раскраске AlphaFold)
* **70–90** = Уверенно (голубой/светло-синий)
* **50–70** = Низкая уверенность (жёлтый) — следует интерпретировать с осторожностью
* **<50** = Очень низкая уверенность (оранжевый/красный) — вероятно, неупорядоченный участок
  {% endhint %}

***

## Рекомендации по 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 ГБ | [голое железо](https://clore.ai/bare-metal) | \~800 а. о. без проблем               | \~3 секунды                          |
| A100 80 ГБ | 80 ГБ | [голое железо](https://clore.ai/bare-metal) | \~1500+ а. о., крупные белки          | \~4 секунды                          |

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

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

**Высокопроизводительная протеомика:** Для скрининга тысяч последовательностей A100 40GB ([голое железо](https://clore.ai/bare-metal)) с пакетным выводом обрабатывает \~1,200+ предсказаний в час — подходит для исследований на масштабе протеома.

***

## Ресурсы

* 🐙 **GitHub:** [github.com/facebookresearch/esm](https://github.com/facebookresearch/esm)
* 🤗 **Модели:** [huggingface.co/facebook/esmfold\_v1](https://huggingface.co/facebook/esmfold_v1)
* 📄 **Статья:** [Предсказание структуры белка на атомном уровне в эволюционном масштабе с помощью языковой модели (Science, 2023)](https://www.science.org/doi/10.1126/science.ade2574)
* 🌐 **ESM Metagenomic Atlas:** [esmatlas.com](https://esmatlas.com) — предсказано 772 млн структур с помощью ESMFold
* 💻 **Блог Meta AI:** [ai.meta.com/blog/protein-folding-esmfold-metagenomics](https://ai.meta.com/blog/protein-folding-esmfold-metagenomics/)
* 🔬 **Журнал изменений ESM:** [github.com/facebookresearch/esm/blob/main/CHANGELOG.md](https://github.com/facebookresearch/esm/blob/main/CHANGELOG.md)


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/nauka-i-issledovaniya/esmfold.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.