# ESM

## Обзор

На этой странице представлены код и предобученные веса трансформерных языковых моделей для белков от команды Fundamental AI Research в Meta AI, включая передовые ESMFold и ESM-2, а также ранее выпущенные ESM-1b и ESM-1v. Трансформерные языковые модели для белков были представлены в статье [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) авторов Александра Ривса, Джошуа Майера, Тома Серку, Сиддхарта Гояла, Цеминга Линя, Джейсона Лю, Демии Гуо, Майла Отта, К. Лоуренса Зитника, Джерри Ма и Роберта Фергюса. Первая версия этой статьи была [опубликована как препринт в 2019 году](https://www.biorxiv.org/content/10.1101/622803v1?versioned=true).

ESM-2 превосходит все протестированные одноцепочечные языковые модели белков на широком спектре задач предсказания структуры и позволяет осуществлять предсказание структуры с атомарным разрешением. Модель была выпущена вместе со статьёй [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902), авторами которой являются Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido и Alexander Rives.

В этой же статье был представлен ESMFold. Он использует ствол ESM-2 с головой, способной предсказывать структуры свернутых белков с точностью, соответствующей современному уровню развития. В отличие от [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2), он опирается на токеновые эмбеддинги из ствола крупномасштабной предобученной языковой модели для белков и не выполняет этап множественного выравнивания последовательностей (MSA) во время инференса. Это означает, что чекпоинты ESMFold полностью «автономны»: для выполнения предсказаний им не требуется база данных известных белковых последовательностей и структур с соответствующими внешними инструментами запросов, что делает их значительно более быстрыми.

Аннотация к статье «Биологическая структура и функция возникают при масштабировании обучения без учителя до 250 миллионов белковых последовательностей»

*В области искусственного интеллекта сочетание масштаба данных и вычислительной мощности моделей, обеспеченное обучением без учителя, привело к значительным прорывам в области обучения представлений и статистической генерации. В области наук о жизни ожидаемый рост секвенирования обещает беспрецедентные данные о естественном разнообразии последовательностей. Языковое моделирование белков в масштабе эволюции является логическим шагом к предсказательному и генеративному искусственному интеллекту для биологии. С этой целью мы используем обучение без учителя для обучения глубокой контекстной языковой модели на 86 миллиардах аминокислот в 250 миллионах белковых последовательностей, охватывающих эволюционное разнообразие. Полученная модель содержит информацию о биологических свойствах в своих представлениях. Представления обучаются исключительно на данных последовательностей. Пространство изученных представлений имеет многомасштабную организацию, отражающую структуру от уровня биохимических свойств аминокислот до отдаленной гомологии белков. Информация о вторичной и третичной структуре закодирована в представлениях и может быть выявлена с помощью линейных проекций. Обучение представлений порождает признаки, которые обобщаются на широкий спектр приложений, обеспечивая предсказание мутационного эффекта и вторичной структуры с использованием обучения с учителем на уровне передовых методов, а также улучшая признаки передовых методов для предсказания дальних контактов.*

Аннотация к статье «Модели языков последовательностей белков в масштабе эволюции обеспечивают точное предсказание структуры»

*Недавно было показано, что крупные языковые модели с ростом масштаба обретают эмерджентные возможности, выходящие за рамки простого сопоставления паттернов: они способны выполнять рассуждения более высокого уровня и генерировать реалистичные изображения и текст. Хотя языковые модели, обученные на последовательностях белков, изучались в меньшем масштабе, мало что известно о том, что они усваивают о биологии при увеличении их размера. В данной работе мы обучаем модели с числом параметров до 15 миллиардов — это самые крупные языковые модели белков, когда-либо подвергавшиеся оценке. Мы обнаруживаем, что по мере масштабирования модели усваивают информацию, позволяющую предсказывать трёхмерную структуру белка с разрешением отдельных атомов. Мы представляем ESMFold для предсказания атомарной структуры белка с высокой точностью в режиме end-to-end непосредственно по его отдельной последовательности. Для последовательностей с низкой перплексией, хорошо понимаемых языковой моделью, точность ESMFold сопоставима с точностью AlphaFold2 и RoseTTAFold. Вывод ESMFold выполняется на порядок быстрее, чем AlphaFold2, что позволяет исследовать структурное пространство метагеномных белков в практические сроки.*

Исходный код можно найти [здесь](https://github.com/facebookresearch/esm); он был разработан командой Fundamental AI Research в Meta AI. Модели ESM-1b, ESM-1v и ESM-2 были добавлены в huggingface пользователями [jasonliu](https://huggingface.co/jasonliu) и [Matt](https://huggingface.co/Rocketknight1).

ESMFold был добавлен в huggingface [Matt](https://huggingface.co/Rocketknight1) и [Sylvain](https://huggingface.co/sgugger). Огромное спасибо Nikita Smetanin, Roshan Rao и Tom Sercu за помощь на всех этапах!

## Советы по использованию

- Модели ESM обучаются с использованием цели маскированного языкового моделирования (MLM).
- Порт ESMFold для HuggingFace использует части библиотеки [openfold](https://github.com/aqlaboratory/openfold). Библиотека `openfold` распространяется по лицензии Apache License 2.0.

## Ресурсы

- [Руководство по задаче классификации текста](../tasks/sequence_classification)
- [Руководство по задаче классификации токенов](../tasks/token_classification)
- [Руководство по задаче маскированного языкового моделирования](../tasks/masked_language_modeling)

## EsmConfig[[transformers.EsmConfig]]

#### transformers.EsmConfig[[transformers.EsmConfig]]

```python
transformers.EsmConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int | None = None, mask_token_id: int | None = None, pad_token_id: int | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_dropout_prob: float | None = 0.1, attention_probs_dropout_prob: float | None = 0.1, max_position_embeddings: int = 1026, rope_theta: float = 10000.0, initializer_range: float = 0.02, layer_norm_eps: float | None = 1e-12, position_embedding_type: str | None = 'absolute', use_cache: bool = True, emb_layer_norm_before: bool | None = None, token_dropout: bool | None = False, is_folding_model: bool | None = False, esmfold_config: dict | transformers.models.esm.configuration_esm.EsmFoldConfig | None = None, vocab_list: list[str] | tuple[str, ...] | None = None, is_decoder: bool | None = False, add_cross_attention: bool | None = False, tie_word_embeddings: bool = True, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = 2)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/configuration_esm.py#L157)

**Параметры:**

vocab_size (`int`, *необязательный*) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

mask_token_id (`int`, *optional*) : Индекс токена маски в словаре. Это значение должно быть указано в конфигурации из-за приёма масштабирования «mask-dropout», который масштабирует входные данные в зависимости от количества замаскированных токенов.

pad_token_id (`int`, *необязательный*) : Идентификатор токена, используемый для выравнивания в словаре.

hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *optional*, по умолчанию `3072`) : Размерность представлений MLP.

hidden_dropout_prob (`float`, *необязательный*, по умолчанию `0.1`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пуллере.

attention_probs_dropout_prob (`float`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания.

max_position_embeddings (`int`, *необязательный*, по умолчанию `1026`) : Максимальная длина последовательности, с которой может использоваться данная модель.

rope_theta (`float`, по умолчанию 10000.0) : Базовый период для вложений RoPE. Используется только тогда, когда `position_embedding_type` установлен в значение `"rotary"`.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации.

position_embedding_type (`str`, *необязательный*, по умолчанию `"absolute"`) : Тип позиционного эмбеддинга. Выберите `"absolute"` или "rotary"`.

use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером.

emb_layer_norm_before (`bool`, *необязательный*) : Нужно ли применять нормализацию слоя после эмбеддингов, но до основного стека сети.

token_dropout (`bool`, по умолчанию `False`) : Если включено, маскированные токены обрабатываются так, как если бы они были отброшены входным dropout.

is_folding_model (`bool`, по умолчанию `False`) : Если включено, модель ESMFold будет инициализирована.

esmfold_config (`dict`, *необязательный*) : Конфигурация для инициализации модуля ESMFold.

vocab_list (`list`, *необязательный*) : Список элементов словаря.

is_decoder (`bool`, *необязательный*, по умолчанию `False`) : Указывает, используется ли модель в качестве декодера. Если `False`, модель используется как энкодер.

add_cross_attention (`bool`, *необязательный*, по умолчанию `False`) : Следует ли добавлять слои кросс-внимания в модель.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

bos_token_id (`int`, *optional*) : Идентификатор токена, используемый для обозначения начала потока в словаре.

eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого для обозначения конца потока в словаре.

Это класс конфигурации для хранения настроек модели EsmModel. Он используется для создания модели Esm в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [facebook/esm-1b](https://huggingface.co/facebook/esm-1b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Примеры:

```python
>>> from transformers import EsmModel, EsmConfig

>>> # Initializing a ESM facebook/esm-1b style configuration
>>> configuration = EsmConfig(vocab_size=33)

>>> # Initializing a model from the configuration
>>> model = EsmModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## EsmTokenizer[[transformers.EsmTokenizer]]

#### transformers.EsmTokenizer[[transformers.EsmTokenizer]]

```python
transformers.EsmTokenizer(vocab_file, unk_token = '<unk>', cls_token = '<cls>', pad_token = '<pad>', mask_token = '<mask>', eos_token = '<eos>', **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L33)

Создает токенизатор ESM.

#### build_inputs_with_special_tokens[[transformers.EsmTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L89)

#### get_special_tokens_mask[[transformers.EsmTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L103)

**Параметры:**

token_ids_0 (`list[int]`) : Список идентификаторов первой последовательности.

token_ids_1 (`list[int]`, *необязательный*) : Список идентификаторов второй последовательности.

already_has_special_tokens (`bool`, *необязательный*, по умолчанию `False`) : Указывает, является ли список токенов уже отформатированным со специальными токенами для модели.

**Возвращаемое значение:** список целых чисел в диапазоне [0, 1]

1 для специального токена, 0 для токена последовательности.

Получает идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены. Этот метод вызывается при добавлении специальных токенов с помощью методов `prepare_for_model` или `encode_plus` токенизатора.

#### create_token_type_ids_from_sequences[[transformers.EsmTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301)

**Параметры:**

token_ids_0 (`list[int]`) : Список идентификаторов.

token_ids_1 (`list[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей.

**Возвращает:** `list[int]`

Идентификаторы типов токенов в соответствии с настроенным шаблоном.

Создайте маску из двух переданных последовательностей для использования в задаче классификации пар последовательностей.

Этот метод динамически формирует идентификаторы типов токенов на основе атрибутов конфигурации токенизатора:
- `token_type_ids_pattern`: Шаблон для использования ("all_zeros" или "bert_style")
- `token_type_ids_include_special_tokens`: Учитывать ли специальные токены при вычислении длины

Примеры:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.EsmTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory, filename_prefix)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/tokenization_esm.py#L135)

## EsmModel[[transformers.EsmModel]]

#### transformers.EsmModel[[transformers.EsmModel]]

```python
transformers.EsmModel(config: EsmConfig, add_pooling_layer = True)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L606)

**Параметры:**

config ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга

Модель Esm без дополнительных слоёв, выводящая необработанные скрытые состояния.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EsmModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L674)

**Параметры:**

input_ids (`torch.LongTensor` формы `((batch_size, sequence_length))`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `((batch_size, sequence_length))`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.max_position_embeddings - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `((batch_size, sequence_length), hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер.

encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.

**Возвращает:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) или `tuple(torch.Tensor)`

Объект [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) и входных данных.

Метод forward класса [EsmModel](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` и `config.add_cross_attention=True` или если `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования.

## EsmForMaskedLM[[transformers.EsmForMaskedLM]]

#### transformers.EsmForMaskedLM[[transformers.EsmForMaskedLM]]

```python
transformers.EsmForMaskedLM(config: EsmConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L795)

**Параметры:**

config ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Esm с головой `language modeling` сверху."

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EsmForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L818)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер.

encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

**Возвращает:** [MaskedLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) или `tuple(torch.Tensor)`

Объект [MaskedLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) и входных данных.

Метод [EsmForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmForMaskedLM) forward переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери маскированного языкового моделирования (MLM).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, EsmForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForMaskedLM.from_pretrained("facebook/esm-1b")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...
```

## EsmForSequenceClassification[[transformers.EsmForSequenceClassification]]

#### transformers.EsmForSequenceClassification[[transformers.EsmForSequenceClassification]]

```python
transformers.EsmForSequenceClassification(config: EsmConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L888)

**Параметры:**

config ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер модели ESM с головной частью для классификации/регрессии последовательности (линейный слой поверх пуллинг-выхода), например, для задач GLUE.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EsmForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L899)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия).

**Возвращает:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или `tuple(torch.Tensor)`

Объект [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) и входных данных.

Метод forward класса [EsmForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmForSequenceClassification) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1).
- **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример классификации с одной меткой:

```python
>>> import torch
>>> from transformers import AutoTokenizer, EsmForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Пример многоклассовой классификации:

```python
>>> import torch
>>> from transformers import AutoTokenizer, EsmForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm-1b", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = EsmForSequenceClassification.from_pretrained(
...     "facebook/esm-1b", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## EsmForTokenClassification[[transformers.EsmForTokenClassification]]

#### transformers.EsmForTokenClassification[[transformers.EsmForTokenClassification]]

```python
transformers.EsmForTokenClassification(config: EsmConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L954)

**Параметры:**

config ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер Esm с головой классификации токенов (линейный слой поверх выходных скрытых состояний), например, для задач распознавания именованных сущностей (NER).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EsmForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esm.py#L965)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления функции потерь классификации токенов. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`.

**Возвращает:** [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или `tuple(torch.Tensor)`

Объект [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) и входных данных.

Метод [EsmForTokenClassification](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmForTokenClassification) forward переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации.
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.num_labels)`) — Оценки классификации (до SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, EsmForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm-1b")
>>> model = EsmForTokenClassification.from_pretrained("facebook/esm-1b")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## EsmForProteinFolding[[transformers.EsmForProteinFolding]]

#### transformers.EsmForProteinFolding[[transformers.EsmForProteinFolding]]

```python
transformers.EsmForProteinFolding(config: EsmConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esmfold.py#L1966)

**Параметры:**

config ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

ESMForProteinFolding — это порт оригинальной модели ESMFold для HuggingFace. Она состоит из «ствола» ESM-2 и «головы» для предсказания структуры белка, хотя, в отличие от большинства других выходных «голов», эта «голова» сопоставима по размеру и времени выполнения со всей остальной частью модели! На выходе она возвращает словарь, содержащий предсказанную структурную информацию о входном белке (белках).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.EsmForProteinFolding.forward]]

```python
forward(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, masking_pattern: typing.Optional[torch.Tensor] = None, num_recycles: int | None = None, output_hidden_states: bool | None = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/esm/modeling_esmfold.py#L2044)

**Параметры:**

input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

masking_pattern (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Позиции токенов, которые следует маскировать во время обучения в качестве формы регуляризации. Значения маски выбираются из `[0, 1]`.

num_recycles (`int`, *optional*, по умолчанию `None`) : Количество повторного использования входной последовательности. Если `None`, по умолчанию используется `config.num_recycles`. «Повторное использование» заключается в том, что выход свёрточного блока снова подаётся на его вход. Во время обучения количество повторений должно варьироваться для каждой партии, чтобы модель научилась выдавать корректные предсказания после каждого повторения. Во время инференса num_recycles следует установить на максимальное значение, с которым обучалась модель, для достижения максимальной точности. Соответственно, если это значение равно `None`, используется config.max_recycles.

output_hidden_states (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать скрытые состояния всех слоев. Подробнее см. `hidden_states` в разделе возвращаемых тензоров.

**Возвращает:** `EsmForProteinFoldingOutput` или `tuple(torch.Tensor)`

Объект `EsmForProteinFoldingOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([EsmConfig](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmConfig)) и входных данных.

Метод forward класса [EsmForProteinFolding](/docs/transformers/v5.23.0/ru/model_doc/esm#transformers.EsmForProteinFolding) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **frames** (`torch.Tensor`, *необязательный*) -- Выходные кадры.
- **sidechain_frames** (`torch.Tensor`, *необязательный*) -- Выходные кадры боковой цепи.
- **unnormalized_angles** (`torch.Tensor`, *необязательный*) -- Предсказанные ненормализованные углы торсии каркаса и боковых цепей.
- **angles** (`torch.Tensor`, *optional*) -- Предсказанные углы торсии каркаса и боковых цепей.
- **positions** (`torch.Tensor`, *необязательный*) -- Предсказанные позиции атомов каркаса и боковых цепей.
- **states** (`torch.Tensor`, *optional*) -- Скрытые состояния из стержневой части модели сворачивания белка.
- **s_s** (`torch.Tensor`, *необязательный*) -- Встраивания для каждого остатка, полученные путём конкатенации скрытых состояний каждого слоя стека ESM-2 LM.
- **s_z** (`torch.Tensor`, *необязательный*) -- Парные эмбеддинги остатков.
- **distogram_logits** (`torch.Tensor`, *необязательный*) -- Входные логиты для дистограммы, используемые для вычисления расстояний между остатками.
- **lm_logits** (`torch.Tensor`, *необязательный*) -- Выходные логиты, сгенерированные основной частью языковой модели белков ESM-2.
- **aatype** (`torch.Tensor`, *optional*) -- Входящие аминокислоты (индексы AlphaFold2).
- **atom14_atom_exists** (`torch.Tensor`, *optional*) -- Указывает, существует ли каждый атом в представлении atom14.
- **residx_atom14_to_atom37** (`torch.Tensor`, *optional*) -- Mapping between atoms in the atom14 and atom37 representations.
- **residx_atom37_to_atom14** (`torch.Tensor`, *optional*) -- Mapping between atoms in the atom37 and atom14 representations.
- **atom37_atom_exists** (`torch.Tensor`, *optional*) -- Указывает, существует ли каждый атом в представлении atom37.
- **residue_index** (`torch.Tensor`, *optional*) -- Индекс каждого остатка в цепочке белка. Если внутренние токены отступов не используются, это будет просто последовательность целых чисел от 0 до `sequence_length`.
- **lddt_head** (`torch.Tensor`, *optional*) -- Исходные выходные данные lddt-головы, используемые для вычисления plddt.
- **plddt** (`torch.Tensor`, *optional*) -- Оценки уверенности для каждого остатка. Области с низкой уверенностью могут указывать на участки, где предсказание модели неопределенно, или где структура белка является неупорядоченной.
- **ptm_logits** (`torch.Tensor`, *необязательный*) -- Исходные логиты, используемые для вычисления ptm.
- **ptm** (`torch.Tensor`, *необязательный*) -- выход TM-score, отражающий общую уверенность модели в структуре в целом.
- **aligned_confidence_probs** (`torch.Tensor`, *необязательный*) -- Оценки уверенности для каждого остатка в выровненной структуре.
- **predicted_aligned_error** (`torch.Tensor`, *необязательный*) -- Предсказанная ошибка между предсказанием модели и эталонными данными.
- **max_predicted_aligned_error** (`torch.Tensor`, *необязательный*) -- Максимальная предсказанная ошибка для каждого примера.

Пример:

```python
>>> from transformers import AutoTokenizer, EsmForProteinFolding

>>> model = EsmForProteinFolding.from_pretrained("facebook/esmfold_v1")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esmfold_v1")
>>> inputs = tokenizer(["MLKNVQVQLV"], return_tensors="pt", add_special_tokens=False)  # A tiny random peptide
>>> outputs = model(**inputs)
>>> folded_positions = outputs.positions
```

