# ESM

## Visão geral

Esta página fornece código e pesos pré-treinados para modelos de linguagem de proteínas Transformer da Fundamental AI Research Team da Meta AI, oferecendo o ESMFold e o ESM-2, que representam o estado da arte, além dos ESM-1b e ESM-1v, lançados anteriormente. Os modelos de linguagem de proteínas Transformer foram introduzidos no artigo [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118), de Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma e Rob Fergus. A primeira versão deste artigo foi [publicada como preprint em 2019](https://www.biorxiv.org/content/10.1101/622803v1?versioned=true).

O ESM-2 supera todos os modelos de linguagem de proteínas de sequência única testados em uma variedade de tarefas de predição de estrutura e permite a predição de estrutura em resolução atômica. Foi lançado junto com o artigo [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902), de Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido e Alexander Rives.

Também foi introduzido neste artigo o ESMFold. Ele utiliza um tronco ESM-2 com uma cabeça capaz de prever estruturas de proteínas dobradas com precisão de estado da arte. Diferentemente do [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2), ele depende dos embeddings de tokens do grande modelo de linguagem de proteínas pré-treinado (tronco) e não executa uma etapa de alinhamento múltiplo de sequências (MSA) no momento da inferência. Isso significa que os checkpoints do ESMFold são totalmente "autônomos" — eles não exigem um banco de dados de sequências e estruturas de proteínas conhecidas, com ferramentas de consulta externas associadas, para fazer previsões, e, como resultado, são muito mais rápidos.

The abstract from "Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences" is

*No campo da inteligência artificial, a combinação de escala em dados e capacidade de modelo, viabilizada pelo aprendizado não supervisionado, levou a avanços significativos no aprendizado de representações e na geração estatística. Nas ciências da vida, o crescimento previsto do sequenciamento promete dados sem precedentes sobre a diversidade natural de sequências. A modelagem de linguagem de proteínas na escala da evolução é um passo lógico rumo à inteligência artificial preditiva e generativa para a biologia. Para isso, usamos aprendizado não supervisionado para treinar um modelo de linguagem contextual profundo em 86 bilhões de aminoácidos em 250 milhões de sequências de proteínas abrangendo a diversidade evolutiva. O modelo resultante contém informações sobre propriedades biológicas em suas representações. As representações são aprendidas apenas a partir de dados de sequência. O espaço de representações aprendido possui uma organização multiescala que reflete a estrutura, do nível das propriedades bioquímicas dos aminoácidos à homologia remota de proteínas. Informações sobre estrutura secundária e terciária são codificadas nas representações e podem ser identificadas por projeções lineares. O aprendizado de representações produz características que se generalizam em uma variedade de aplicações, permitindo a previsão supervisionada de efeito mutacional e estrutura secundária com o estado da arte, além de melhorar as características de estado da arte para a previsão de contatos de longo alcance.*

The abstract from "Language models of protein sequences at the scale of evolution enable accurate structure prediction" is

*Recentemente, demonstrou-se que os grandes modelos de linguagem desenvolvem capacidades emergentes à medida que aumentam de escala, indo além da simples correspondência de padrões para realizar raciocínio de alto nível e gerar imagens e textos realistas. Embora modelos de linguagem treinados em sequências de proteínas tenham sido estudados em menor escala, pouco se sabe sobre o que eles aprendem sobre biologia quando são ampliados. Neste trabalho, treinamos modelos com até 15 bilhões de parâmetros, os maiores modelos de linguagem de proteínas avaliados até o momento. Descobrimos que, à medida que os modelos são ampliados, eles aprendem informações que permitem a predição da estrutura tridimensional de uma proteína na resolução de átomos individuais. Apresentamos o ESMFold para predição de estrutura em nível atômico de ponta a ponta com alta precisão, diretamente a partir da sequência individual de uma proteína. O ESMFold tem precisão semelhante à do AlphaFold2 e do RoseTTAFold para sequências com baixa perplexidade que são bem compreendidas pelo modelo de linguagem. A inferência do ESMFold é uma ordem de grandeza mais rápida que a do AlphaFold2, permitindo a exploração do espaço estrutural de proteínas metagenômicas em escalas de tempo práticas.*

O código original pode ser encontrado [aqui](https://github.com/facebookresearch/esm) e foi desenvolvido pela equipe Fundamental AI Research da Meta AI. ESM-1b, ESM-1v e ESM-2 foram contribuídos para o huggingface por [jasonliu](https://huggingface.co/jasonliu) e [Matt](https://huggingface.co/Rocketknight1).

O ESMFold foi contribuído para o huggingface por [Matt](https://huggingface.co/Rocketknight1) e [Sylvain](https://huggingface.co/sgugger), com um grande agradecimento a Nikita Smetanin, Roshan Rao e Tom Sercu pela ajuda ao longo de todo o processo!

## Dicas de uso

- Os modelos ESM são treinados com um objetivo de modelagem de linguagem mascarada (MLM).
- A versão do ESMFold da HuggingFace utiliza partes da biblioteca [openfold](https://github.com/aqlaboratory/openfold). A biblioteca `openfold` é licenciada sob a Apache License 2.0.

## Recursos

- [Guia da tarefa de classificação de texto](../tasks/sequence_classification)
- [Guia de tarefas de classificação de tokens](../tasks/token_classification)
- [Guia da tarefa de modelagem de linguagem mascarada](../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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/configuration_esm.py#L157)

**Parâmetros:**

vocab_size (`int`, *opcional*) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

mask_token_id (`int`, *opcional*) : O índice do token de máscara no vocabulário. Isso deve estar incluído na configuração devido ao truque de escala "mask-dropout", que escala as entradas com base no número de tokens mascarados.

pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP.

hidden_dropout_prob (`float`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

attention_probs_dropout_prob (`float`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção.

max_position_embeddings (`int`, *opcional*, padrão `1026`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

rope_theta (`float`, padrão 10000.0) : O período base dos embeddings RoPE. Usado apenas quando `position_embedding_type` está definido como `"rotary"`.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada.

position_embedding_type (`str`, *opcional*, padrão `"absolute"`) : Tipo de incorporação de posição. Escolha entre `"absolute"` ou "rotary"`.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

emb_layer_norm_before (`bool`, *opcional*) : Se deve aplicar a normalização de camada após os embeddings, mas antes do tronco principal da rede.

token_dropout (`bool`, padrão `False`) : Quando habilitado, os tokens mascarados são tratados como se tivessem sido descartados pelo dropout de entrada.

is_folding_model (`bool`, padrão `False`) : Quando habilitado, o modelo ESMFold será inicializado.

esmfold_config (`dict`, *opcional*) : Configuração para iniciar o módulo ESMFold.

vocab_list (`list`, *opcional*) : Lista dos itens do vocabulário.

is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador.

add_cross_attention (`bool`, *opcional*, padrão `False`) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

bos_token_id (`int`, *opcional*) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um EsmModel. Ela é usada para instanciar um modelo Esm de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/esm-1b](https://huggingface.co/facebook/esm-1b)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/tokenization_esm.py#L33)

Constrói um tokenizador ESM.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/tokenization_esm.py#L103)

**Parâmetros:**

token_ids_0 (`list[int]`) : Lista de ids da primeira sequência.

token_ids_1 (`list[int]`, *opcional*) : Lista de ids da segunda sequência.

already_has_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se a lista de tokens já está formatada com tokens especiais para o modelo.

**Retorna:** Uma lista de inteiros no intervalo [0, 1]

1 para um token especial, 0 para um token de sequência.

Recupera os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Este método é chamado ao adicionar tokens especiais usando os métodos `prepare_for_model` ou `encode_plus` do tokenizer.

#### criar_ids_de_tipo_de_token_a_partir_de_sequências[[transformers.EsmTokenizer.create_token_type_ids_from_sequences]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1298)

**Parâmetros:**

token_ids_0 (`list[int]`) : Lista de IDs.

token_ids_1 (`list[int]`, *opcional*) : Lista opcional de IDs para pares de sequências.

**Retorna:** `list[int]`

IDs de tipo de token de acordo com o padrão configurado.

Crie uma máscara a partir das duas sequências passadas para ser usada em uma tarefa de classificação de pares de sequências.

Este método constrói dinamicamente os IDs de tipo de token com base nos atributos de configuração do tokenizer:
- `token_type_ids_pattern`: Padrão a ser usado ("all_zeros" ou "bert_style")
- `token_type_ids_include_special_tokens`: Se deve considerar tokens especiais no cálculo do comprimento

Exemplos:
```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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/tokenization_esm.py#L135)

## EsmModel[[transformers.EsmModel]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L606)

**Parâmetros:**

config ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve adicionar uma camada de pooling

O modelo Esm básico, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L674)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `((batch_size, sequence_length))`) : Índices dos tokens da sequência de entrada no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `((batch_size, sequence_length))`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.max_position_embeddings - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `((batch_size, sequence_length), hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.

encoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.

**Retorna:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) e das entradas.

O método forward do [EsmModel](/docs/transformers/main/pt/model_doc/esm#transformers.EsmModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` e `config.add_cross_attention=True` são passados, ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.

## EsmForMaskedLM[[transformers.EsmForMaskedLM]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L795)

**Parâmetros:**

config ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Esm com uma cabeça de `language modeling` no topo."

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L818)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.

encoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

**Retorna:** [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou `tuple(torch.Tensor)`

Um [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) e das entradas.

O método forward de [EsmForMaskedLM](/docs/transformers/main/pt/model_doc/esm#transformers.EsmForMaskedLM) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem mascarada (MLM).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L888)

**Parâmetros:**

config ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo transformer ESM com uma cabeça de classificação/regressão de sequência no topo (uma camada linear sobre a saída agregada), por exemplo, para tarefas GLUE.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L899)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada).

**Retorna:** [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) e das entradas.

O método forward de [EsmForSequenceClassification](/docs/transformers/main/pt/model_doc/esm#transformers.EsmForSequenceClassification) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo de classificação de rótulo único:

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

Exemplo de classificação multirótulo:

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L954)

**Parâmetros:**

config ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O Esm transformer com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos hidden-states), por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esm.py#L965)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`.

**Retorna:** [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)`

Um [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) e das entradas.

O método forward de [EsmForTokenClassification](/docs/transformers/main/pt/model_doc/esm#transformers.EsmForTokenClassification) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Pontuações de classificação (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esmfold.py#L1966)

**Parâmetros:**

config ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

ESMForProteinFolding é a port do HuggingFace do modelo original ESMFold. Ele consiste em um "tronco" ESM-2 seguido de um "cabeçalho" de dobramento de proteínas, embora, ao contrário da maioria dos outros cabeçalhos de saída, esse "cabeçalho" seja semelhante em tamanho e tempo de execução ao restante do modelo combinado! Ele produz um dicionário contendo informações estruturais previstas sobre a(s) proteína(s) de entrada.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esm/modeling_esmfold.py#L2042)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obter detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

masking_pattern (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Posições dos tokens a serem mascarados durante o treinamento como forma de regularização. Valores de máscara selecionados em `[0, 1]`.

num_recycles (`int`, *opcional*, padrão `None`) : Número de vezes para reciclar a sequência de entrada. Se `None`, o padrão é `config.num_recycles`. "Reciclar" consiste em passar a saída do tronco de dobragem de volta como entrada para o tronco. Durante o treinamento, o número de reciclagens deve variar a cada lote, para garantir que o modelo aprenda a produzir previsões válidas após cada reciclagem. Durante a inferência, num_recycles deve ser definido como o valor mais alto com o qual o modelo foi treinado, para máxima precisão. Consequentemente, quando esse valor é definido como `None`, config.max_recycles é usado.

output_hidden_states (`bool`, *opcional*, padrão `False`) : Indica se os estados ocultos de todas as camadas devem ser retornados ou não. Consulte `hidden_states` em tensores retornados para mais detalhes.

**Retorna:** `EsmForProteinFoldingOutput` ou `tuple(torch.Tensor)`

Um `EsmForProteinFoldingOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([EsmConfig](/docs/transformers/main/pt/model_doc/esm#transformers.EsmConfig)) e das entradas.

O método forward de [EsmForProteinFolding](/docs/transformers/main/pt/model_doc/esm#transformers.EsmForProteinFolding) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **frames** (`torch.Tensor`, *opcional*) -- Quadros de saída.
- **sidechain_frames** (`torch.Tensor`, *opcional*) -- Quadros de sidechain de saída.
- **unnormalized_angles** (`torch.Tensor`, *opcional*) -- Ângulos de torção não normalizados previstos para a estrutura principal e as cadeias laterais.
- **angles** (`torch.Tensor`, *opcional*) -- Ângulos de torção previstos para a estrutura principal e as cadeias laterais.
- **positions** (`torch.Tensor`, *opcional*) -- Posições previstas dos átomos da cadeia principal e das cadeias laterais.
- **states** (`torch.Tensor`, *opcional*) -- Estados ocultos do tronco de dobramento de proteínas.
- **s_s** (`torch.Tensor`, *opcional*) -- Incorporações por resíduo derivadas pela concatenação dos estados ocultos de cada camada do tronco do LM ESM-2.
- **s_z** (`torch.Tensor`, *opcional*) -- Incorporações de resíduos em pares.
- **distogram_logits** (`torch.Tensor`, *opcional*) -- Logits de entrada para o distograma usado para calcular as distâncias entre resíduos.
- **lm_logits** (`torch.Tensor`, *opcional*) -- Logits produzidos pelo tronco do modelo de linguagem de proteínas ESM-2.
- **aatype** (`torch.Tensor`, *opcional*) -- Aminoácidos de entrada (índices do AlphaFold2).
- **atom14_atom_exists** (`torch.Tensor`, *opcional*) -- Indica se cada átomo existe na representação atom14.
- **residx_atom14_to_atom37** (`torch.Tensor`, *opcional*) -- Mapeamento entre átomos nas representações atom14 e atom37.
- **residx_atom37_to_atom14** (`torch.Tensor`, *opcional*) -- Mapeamento entre átomos nas representações atom37 e atom14.
- **atom37_atom_exists** (`torch.Tensor`, *opcional*) -- Indica se cada átomo existe na representação atom37.
- **residue_index** (`torch.Tensor`, *opcional*) -- O índice de cada resíduo na cadeia de proteína. A menos que tokens de preenchimento internos sejam usados, isso será apenas uma sequência de inteiros de 0 a `sequence_length`.
- **lddt_head** (`torch.Tensor`, *opcional*) -- Saídas brutas da cabeça lddt usadas para calcular plddt.
- **plddt** (`torch.Tensor`, *opcional*) -- Pontuações de confiança por resíduo. Regiões de baixa confiança podem indicar áreas em que a previsão do modelo é incerta ou em que a estrutura da proteína é desordenada.
- **ptm_logits** (`torch.Tensor`, *opcional*) -- Logits brutos usados para calcular o ptm.
- **ptm** (`torch.Tensor`, *opcional*) -- Saída do TM-score que representa a confiança de alto nível do modelo na estrutura geral.
- **aligned_confidence_probs** (`torch.Tensor`, *opcional*) -- Pontuações de confiança por resíduo para a estrutura alinhada.
- **predicted_aligned_error** (`torch.Tensor`, *opcional*) -- Erro previsto entre a previsão do modelo e o valor real.
- **max_predicted_aligned_error** (`torch.Tensor`, *opcional*) -- Erro máximo previsto por amostra.

Exemplo:

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