# ESMFold2

## Visão geral

ESMFold2 é um modelo de previsão de estrutura proteica em nível de todos os átomos. Ele prevê coordenadas 3D e a confiança por resíduo (pLDDT, PAE, PDE) diretamente a partir de uma sequência de aminoácidos, utilizando o modelo de linguagem proteica [ESMC](./esmc) como sua espinha dorsal. A arquitetura combina um codificador de átomos com janela deslizante e embeddings de posição rotacional 3D, um tronco de dobramento par a par aplicado iterativamente, uma cabeça de estrutura baseada em difusão e uma cabeça de confiança.

O checkpoint do modelo está disponível no Hugging Face Hub em [`biohub/ESMFold2`](https://huggingface.co/biohub/ESMFold2).

## Exemplo de uso

```python
import torch

from transformers import EsmFold2Model

# The ESMC backbone is bundled in the checkpoint and loaded with the model.
# bf16 is the recommended inference precision.
model = EsmFold2Model.from_pretrained("biohub/ESMFold2", dtype=torch.bfloat16, device_map="auto")

pdb_string = model.infer_protein_as_pdb("MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQ")
print(pdb_string)
```

`infer_protein` retorna as saídas brutas (coordenadas dos átomos, logits do distograma e métricas de confiança) como um [EsmFold2Output](/docs/transformers/main/pt/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output), caso você precise delas em vez de uma string PDB. Você pode obter previsões ligeiramente diferentes se executar a mesma sequência várias vezes. Defina uma semente manual se quiser estruturas exatamente reproduzíveis.

O ESMFold2 gera `config.structure_head.num_diffusion_samples` estruturas por dobra. A função `infer_protein_as_pdb` renderiza a de melhor classificação (maior pTM); passe `sample_idx` para selecionar uma amostra específica. O arquivo PDB contém o pLDDT por resíduo na coluna b-factor, na mesma escala de 0 a 1 da saída `plddt`.

### `forward` vs `fold`

A predição de estrutura tem duas partes. `EsmFold2Model.forward` é a primeira: ela executa o tronco de dobramento sobre as entradas featurizadas e retorna a representação de par refinada, além do distograma, como um [EsmFold2TrunkOutput](/docs/transformers/main/pt/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput). Ela não produz coordenadas 3D — o ESMFold2 obtém essas coordenadas por desruido iterativo, e esse loop de amostragem (o agendamento de ruído, o alinhamento de Kabsch e a atualização ODE/SDE) está em `EsmFold2FoldingMixin`, junto com a chamada da cabeça de confiança:

| Método | Use-o para |
| --- | --- |
| `infer_protein_as_pdb(sequence)` | uma string PDB, diretamente de uma sequência de aminoácidos |
| `infer_protein(sequence)` | o [EsmFold2Output](/docs/transformers/main/pt/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output) bruto |
| `fold(**features)` | entradas pré-caracterizadas (o que `infer_protein` chama) |
| `forward(**features)` | somente o tronco — um distograma e uma representação de pares, sem amostragem |

Chame `fold` ou `infer_protein` para obter uma estrutura real. Recorra a `forward` quando você precisar apenas do distograma, ou quando quiser controlar o sampler de difusão por conta própria: `fold` chama `forward` uma vez e, em seguida, passa sua saída para `EsmFold2DiffusionModule`, cujo próprio `forward` é o único passo de remoção de ruído.

## Inferência mais rápida com um kernel fundido

O custo dominante do trunk de dobradiça é a atualização de multiplicação de triângulos. Passar `use_kernels=True` para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) substitui essa operação por um kernel Triton fundido, carregado do Hub por meio da biblioteca [`kernels`](https://github.com/huggingface/kernels), mantendo a previsão inalterada. Essa funcionalidade é exclusiva para inferência e para CUDA; em CPU ou sem o kernel instalado, o modelo faz o fallback transparente para a implementação puramente em PyTorch. Certifique-se de que o modelo esteja em um dispositivo CUDA no momento da kernelização (por exemplo, com `device_map`).

```python
import torch

from transformers import EsmFold2Model

model = EsmFold2Model.from_pretrained(
    "biohub/ESMFold2", dtype=torch.bfloat16, device_map="cuda", use_kernels=True
)

pdb_string = model.infer_protein_as_pdb("MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQ")
```

## EsmFold2Config[[transformers.EsmFold2Config]]

#### transformers.EsmFold2Config[[transformers.EsmFold2Config]]

```python
transformers.EsmFold2Config(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, hidden_size: int | None = 384, pairwise_hidden_size: int | None = 256, single_inputs_size: int | None = 451, pair_transition_intermediate_size: int | None = 1024, sliding_window: int | None = 128, chunk_size: int | None = 64, num_relative_residx_bins: int | None = 32, num_relative_chain_bins: int | None = 2, num_loops: int | None = 10, num_res_types: int | None = 33, max_atomic_number: int | None = 128, char_vocab_size: int | None = 64, max_chars: int | None = 4, max_atoms_per_token: int | None = 23, atom_feature_dim: int | None = None, folding_trunk_num_hidden_layers: int | None = 24, parcae_num_coda_layers: int | None = 2, atom_encoder: dict | transformers.models.esmfold2.configuration_esmfold2.EsmFold2AtomEncoderConfig | None = None, structure_head: dict | transformers.models.esmfold2.configuration_esmfold2.EsmFold2StructureHeadConfig | None = None, confidence_head: dict | transformers.models.esmfold2.configuration_esmfold2.EsmFold2ConfidenceHeadConfig | None = None, msa_encoder: dict | transformers.models.esmfold2.configuration_esmfold2.EsmFold2MsaEncoderConfig | None = None, lm_encoder: dict | transformers.models.esmfold2.configuration_esmfold2.EsmFold2LmEncoderConfig | None = None, esmc_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/configuration_esmfold2.py#L292)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão 384) : Largura da representação única.

pairwise_hidden_size (`int`, *opcional*, padrão 256) : Largura da representação de pares.

single_inputs_size (`int`, *opcional*, padrão 451) : Largura das características de entrada única concatenadas fornecidas ao tronco e à condição de difusão: `atom_encoder.output_dim` mais dois one-hots de tipo de resíduo e o escalar de perfil.

pair_transition_intermediate_size (`int`, *opcional*, padrão 1024) : Largura SwiGLU das transições do par de streams.

sliding_window (`int`, *opcional*, padrão 128) : Tamanho da janela deslizante (distância de índice de token) para a atenção de pilha de átomos, como a largura total da janela em vez do raio.

chunk_size (`int`, *opcional*, padrão 64) : Tamanho do bloco para as operações de pares/MSA-stream que exigem muita memória. `None` desativa o processamento em blocos.

num_relative_residx_bins (`int`, *opcional*, padrão 32) : Número de bins de índice de resíduo relativo na codificação de posição relativa.

num_relative_chain_bins (`int`, *opcional*, padrão 2) : Número de bins de índice de cadeia relativo na codificação de posição relativa.

num_loops (`int`, *opcional*, padrão 10) : Número de loops de refinamento do tronco.

num_res_types (`int`, *opcional*, padrão 33) : Número de tipos de resíduos.

max_atomic_number (`int`, *opcional*, padrão 128) : Tamanho do elemento one-hot nos recursos de átomo.

char_vocab_size (`int`, *opcional*, padrão 64) : Tamanho do vocabulário de caracteres para os nomes de átomos codificados.

max_chars (`int`, *opcional*, padrão 4) : Número de caracteres por nome de átomo codificado.

max_atoms_per_token (`int`, *opcional*, padrão 23) : Número máximo de átomos por token.

atom_feature_dim (`int`, *opcional*) : Largura do recurso atômico: xyz, carga e máscara, além dos one-hots de elemento e caractere do nome do átomo. Derivado de `max_atomic_number`, `char_vocab_size` e `max_chars` se não definido.

folding_trunk_num_hidden_layers (`int`, *opcional*, padrão 24) : Número de blocos de atualização de pares no tronco de dobradiça.

parcae_num_coda_layers (`int`, *opcional*, padrão 2) : Número de blocos de atualização de pares na coda parcae.

atom_encoder (`EsmFold2AtomEncoderConfig`, *opcional*) : Configuração para o codificador de átomos SWA do incorporador de entradas.

structure_head (`EsmFold2StructureHeadConfig`, *opcional*) : Configuração para o cabeçalho de previsão de estrutura por difusão (contém a subconfiguração `diffusion_module`).

confidence_head (`EsmFold2ConfidenceHeadConfig`, *opcional*) : Configuração para a cabeça de confiança.

msa_encoder (`EsmFold2MsaEncoderConfig`, *opcional*) : Configuração para o codificador de MSA.

lm_encoder (`EsmFold2LmEncoderConfig`, *opcional*) : Configuração para o codificador de estados ocultos do modelo de linguagem.

esmc_config ([EsmcConfig](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcConfig), *opcional*) : Configuração para o backbone ESMC integrado.

Esta é a classe de configuração para armazenar a configuração de um Esmfold2Model. Ela é usada para instanciar um modelo Esmfold2 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 [biohub/ESMFold2](https://huggingface.co/biohub/ESMFold2)

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.

#### validate_architecture[[transformers.EsmFold2Config.validate_architecture]]

```python
validate_architecture()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/configuration_esmfold2.py#L387)

Verifica as relações de largura que abrangem subconfigurações; cada subconfiguração verifica a sua própria.

## EsmFold2PreTrainedModel[[transformers.EsmFold2PreTrainedModel]]

#### transformers.EsmFold2PreTrainedModel[[transformers.EsmFold2PreTrainedModel]]

```python
transformers.EsmFold2PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L1848)

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) : 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.

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.

## EsmFold2Model[[transformers.EsmFold2Model]]

#### transformers.EsmFold2Model[[transformers.EsmFold2Model]]

```python
transformers.EsmFold2Model(config: EsmFold2Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L1903)

**Parâmetros:**

config ([EsmFold2Config](/docs/transformers/main/pt/model_doc/esmfold2#transformers.EsmFold2Config)) : 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.

ESMFold2, um preditor de estrutura proteica de todos os átomos com um backbone de modelo de linguagem proteica ESMC integrado. Esta é a arquitetura padrão do ESMFold2 liberado, cujo tronco é uma pilha de recorrente linear (internamente referida como "parcae").

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.EsmFold2Model.forward]]

```python
forward(token_index: Tensor, residue_index: Tensor, asym_id: Tensor, sym_id: Tensor, entity_id: Tensor, mol_type: Tensor, res_type: Tensor, token_bonds: Tensor, attention_mask: Tensor, atom_inputs: EsmFold2AtomInputs, deletion_mean: typing.Optional[torch.Tensor] = None, msa: typing.Optional[torch.Tensor] = None, has_deletion: typing.Optional[torch.Tensor] = None, deletion_value: typing.Optional[torch.Tensor] = None, msa_attention_mask: typing.Optional[torch.Tensor] = None, input_ids: typing.Optional[torch.Tensor] = None, lm_hidden_states: typing.Optional[torch.Tensor] = None, num_loops: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L2188)

**Parâmetros:**

token_index (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Índice posicional por token dentro do complexo completo; alimenta a codificação de posição relativa.

residue_index (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Índice do resíduo dentro de cada cadeia; alimenta a codificação de posição relativa.

asym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de unidade assimétrica (cadeia) para cada token.

sym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de cópia de simetria que distingue cadeias idênticas de um homômero.

entity_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de entidade que agrupa tokens que pertencem à mesma entidade molecular.

mol_type (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Código de tipo de molécula para cada token: `0` = proteína, `1` = DNA, `2` = RNA, `3` = não-polímero (ligante).

res_type (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Índice do tipo resíduo (identidade do aminoácido) para cada token.

token_bonds (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, 1)*) : Recurso de ligação covalente inter-token em pares.

attention_mask (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Máscara que marca tokens válidos (`1`) em relação ao padding (`0`). As entradas devem ser preenchidas à direita.

atom_inputs (*~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs*) : Os tensores de átomos do conformer de referência bruto, agrupados: posições, números atômicos, cargas formais, nomes de átomos codificados, IDs de grupo por átomo, a máscara de padding de átomos e o mapa de átomo->token.

deletion_mean (*torch.Tensor* de forma *(batch_size, num_tokens)*, *opcional*) : Contagem média de exclusões de MSA por coluna. O padrão é zeros (sem MSA).

msa (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Tokens de tipo de resíduo da MSA (a linha 0 é a sequência de consulta). O padrão é uma MSA de sequência única.

has_deletion (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Sinalizador booleano que marca posições de MSA precedidas por uma deleção.

deletion_value (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Contagens de exclusão de MSA por posição.

msa_attention_mask (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Máscara de validade para as linhas/colunas da MSA.

input_ids (*torch.Tensor* de forma *(batch_size, num_tokens)*, *opcional*) : ids de tokens do vocabulário ESMC para a sequência. Enviados para o backbone ESMC embutido para produzir *lm_hidden_states* quando esses não são passados diretamente; ignorados quando *lm_hidden_states* é fornecido.

lm_hidden_states (*torch.Tensor* de forma *(batch_size, num_tokens, num_esmc_layers + 1, esmc_hidden_size)*, *opcional*) : Estados ocultos pré-computados do backbone ESMC, um por camada do backbone, além dos embeddings. Quando fornecidos, o backbone não é executado e *input_ids* não é utilizado.

num_loops (*int*, *optional*) : Número de loops de refinamento do tronco. O padrão é *config.num_loops*.

**Retorna:** [*~models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput*] ou *tuple(torch.Tensor)*

Um [*~models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput*] 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 ([*EsmFold2Config*]) e das entradas.

Execute o tronco de folding: featurize as entradas, embuta-as em uma representação de par, refine-a ao longo de *num_loops* iterações de reciclagem e leia o distograma. Esta é a metade determinística da predição de estrutura; o amostrador de difusão que converte a representação de par retornada em coordenadas 3D está em *EsmFold2FoldingMixin* — chame [*~EsmFold2Model.fold*] ou [*~EsmFold2Model.infer_protein*] para uma predição de ponta a ponta.

- **distogram_logits** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, distogram_bins)*) -- Logits da distribuição de distância prevista para pares de resíduos.
- **pair_states** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- A representação final de pares do tronco, em fp32.
- **single_inputs** (*torch.Tensor* de forma *(batch_size, num_tokens, single_inputs_size)*) -- Recursos de entrada única concatenados construídos pelo incorporador de entradas.
- **relative_position_encoding** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- Codificação de pares de posição relativa.
- **token_bonds_encoding** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- Recurso de ligação covalente entre tokens incorporado.
- **atom_inputs** (*~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs*, *opcional*) -- As entradas de átomos do conformer de referência, com características extraídas, reutilizadas pela pilha de difusão de átomos.

#### dobrar[[transformers.EsmFold2Model.fold]]

```python
fold(attention_mask: Tensor, asym_id: Tensor, mol_type: Tensor, distogram_atom_idx: Tensor, num_diffusion_samples: int | None = None, num_sampling_steps: int | None = None, **trunk_kwargs)
```

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

Preveja uma estrutura de ponta a ponta a partir de entradas com recursos extraídos: execute o tronco (*EsmFold2Model.forward*, que documenta os argumentos de recursos), amostrando coordenadas a partir da cabeça de estrutura de difusão e avaliando-as com a cabeça de confiança.

Apenas os argumentos necessários para o sampler e a confidence head são nomeados aqui; os demais são encaminhados ao trunk sem alterações, de modo que `fold` aceita os mesmos argumentos de `forward`.

attention_mask (*torch.Tensor* de forma *(batch_size, num_tokens)*): Máscara que marca tokens válidos (`1`) em relação ao padding (`0`). Também é encaminhada para o tronco. asym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*): ID de unidade assimétrica (cadeia) para cada token. Também é encaminhado para o tronco. mol_type (*torch.Tensor* de forma *(batch_size, num_tokens)*): Código de tipo de molécula para cada token: `0` = proteína, `1` = DNA, `2` = RNA, `3` = não-polímero (ligante). Também é encaminhado para o tronco. distogram_atom_idx (*torch.Tensor* de forma *(batch_size, num_tokens)*): Índice do átomo representativo (Cβ, ou Cα para glicina) de cada token. Usado pela cabeça de confiança; o tronco não precisa dele. num_diffusion_samples (*int*, *opcional*): Número de amostras de estrutura paralelas a serem extraídas; a cabeça de confiança é reexecutada uma vez por amostra. Padrão: *config.structure_head.num_diffusion_samples*. num_sampling_steps (*int*, *opcional*): Número de etapas de amostragem de difusão. Padrão: *config.structure_head.inference_num_steps*. trunk_kwargs: As entradas restantes com características extraídas (incluindo *num_loops*, além dos tensores brutos por átomo agrupados abaixo em *atom_inputs*), encaminhadas para [*EsmFold2Model.forward*], que as documenta.

#### infer_protein[[transformers.EsmFold2Model.infer_protein]]

```python
infer_protein(sequence: str, **forward_kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/generation_esmfold2.py#L308)

Extraia os recursos de `sequence` e execute o fold. `forward_kwargs` são passados para [*~EsmFold2Model.fold*].

#### infer_protein_as_pdb[[transformers.EsmFold2Model.infer_protein_as_pdb]]

```python
infer_protein_as_pdb(sequence: str, sample_idx: int | None = None, **forward_kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/generation_esmfold2.py#L315)

Dobre a `sequence` e renderize a previsão como uma string PDB.

`sample_idx` seleciona qual amostra de difusão será renderizada; por padrão, a de melhor classificação.

## EsmFold2Output[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output]]

#### transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output]]

```python
transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output(distogram_logits: typing.Optional[torch.Tensor] = None, sample_atom_coords: typing.Optional[torch.Tensor] = None, plddt_logits: typing.Optional[torch.Tensor] = None, plddt: typing.Optional[torch.Tensor] = None, plddt_per_atom: typing.Optional[torch.Tensor] = None, plddt_ca: typing.Optional[torch.Tensor] = None, complex_plddt: typing.Optional[torch.Tensor] = None, complex_iplddt: typing.Optional[torch.Tensor] = None, pae_logits: typing.Optional[torch.Tensor] = None, pae: typing.Optional[torch.Tensor] = None, pde_logits: typing.Optional[torch.Tensor] = None, pde: typing.Optional[torch.Tensor] = None, resolved_logits: typing.Optional[torch.Tensor] = None, ptm: typing.Optional[torch.Tensor] = None, iptm: typing.Optional[torch.Tensor] = None, pair_chains_iptm: typing.Optional[torch.Tensor] = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L1227)

**Parâmetros:**

distogram_logits (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, distogram_bins)`) : Logits da distribuição de distância prevista entre pares de resíduos (independente de RNG; sem amostragem de difusão).

sample_atom_coords (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms, 3)`) : Coordenadas cartesianas de todos os átomos previstas para cada amostra de difusão.

plddt_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms, num_plddt_bins)`) : Logits dos bins de pLDDT por átomo.

plddt (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens)`) : Confiança lDDT prevista por resíduo.

plddt_per_atom (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms)`) : Confiança lDDT prevista por átomo.

plddt_ca (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens)`) : lDDT previsto no átomo representativo (Cα) de cada token.

complex_plddt (`torch.Tensor` de forma `(num_diffusion_samples,)`) : pLDDT médio sobre todos os átomos do complexo.

complex_iplddt (`torch.Tensor` de forma `(num_diffusion_samples,)`) : pLDDT complexo ponderado por interface.

pae_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens, num_pae_bins)`) : Logits dos bins de erro alinhado previsto.

pae (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens)`) : Erro alinhado previsto (Å) esperado para cada par de resíduos.

pde_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens, num_pde_bins)`) : Logits dos bins de erro de distância prevista.

pde (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens)`) : Erro de distância previsto esperado (Å) para cada par de resíduos.

resolved_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms, 2)`) : Logits resolvidos/não resolvidos por átomo.

ptm (`torch.Tensor` de forma `(num_diffusion_samples,)`) : TM-score previsto para cada amostra.

iptm (`torch.Tensor` de forma `(num_diffusion_samples,)`) : TM-score da interface previsto para cada amostra.

pair_chains_iptm (`torch.Tensor` de forma `(num_diffusion_samples, num_chains, num_chains)`) : TM-score de interface previsto para cada par ordenado de cadeias.

Saída de [EsmFold2Model](/docs/transformers/main/pt/model_doc/esmfold2#transformers.EsmFold2Model). Todas as pontuações de confiança estão em uma escala de 0 a 1; os tensores por amostra possuem um eixo inicial `num_diffusion_samples`.

## EsmFold2TrunkOutput[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput]]

#### transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput]]

```python
transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput(distogram_logits: typing.Optional[torch.Tensor] = None, pair_states: typing.Optional[torch.Tensor] = None, single_inputs: typing.Optional[torch.Tensor] = None, relative_position_encoding: typing.Optional[torch.Tensor] = None, token_bonds_encoding: typing.Optional[torch.Tensor] = None, atom_inputs: transformers.models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L1289)

**Parâmetros:**

distogram_logits (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, distogram_bins)`) : Logits da distribuição de distâncias previstos para pares de resíduos.

pair_states (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : A representação final de pares do tronco, em fp32.

single_inputs (`torch.Tensor` de forma `(batch_size, num_tokens, single_inputs_size)`) : Recursos de entrada única concatenados, construídos pelo incorporador de entradas.

relative_position_encoding (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : Codificação de pares de posição relativa.

token_bonds_encoding (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : Recurso de ligação covalente inter-token incorporado.

atom_inputs (`~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs`, *opcional*) : Os inputs de átomos do conformer de referência, com features, reutilizados pela pilha de difusão de átomos.

Saída de [EsmFold2Model.forward()](/docs/transformers/main/pt/model_doc/esmfold2#transformers.EsmFold2Model.forward): a representação de pares do tronco de dobramento, o distograma lido a partir dela e os tensores de condicionamento consumidos pelas cabeças de estrutura e confiança. Tudo aqui é determinístico dado os inputs, exceto pelo estado inicial de par aleatório do tronco.

## EsmFold2AtomInputs[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs]]

#### transformers.models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs[[transformers.models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs]]

```python
transformers.models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs(ref_pos: Tensor, ref_charge: Tensor, atom_attention_mask: Tensor, ref_element: Tensor, ref_atom_name_chars: Tensor, ref_space_uid: Tensor, atom_to_token: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmfold2/modeling_esmfold2.py#L45)

**Parâmetros:**

ref_pos : *(batch_size, num_atoms, 3)* coordenadas cartesianas do conformer de referência.

ref_charge : *(batch_size, num_atoms)* carga formal de cada átomo.

atom_attention_mask : *(batch_size, num_atoms)* átomos válidos (*1*) versus preenchimento (*0*).

ref_element : *(batch_size, num_atoms, max_atomic_number)* número atômico one-hot.

ref_atom_name_chars : *(batch_size, num_atoms, max_chars, char_vocab_size)* nome do átomo em one-hot.

ref_space_uid : *(batch_size, num_atoms)* ID do grupo por átomo (o índice do token do átomo).

atom_to_token : *(batch_size, num_atoms)* índice do token ao qual cada átomo pertence.

Entradas de átomos do conformer de referência com características extraídas, agrupadas para que a pilha de átomos aceite um único argumento.

Recebido como um único argumento por [*EsmFold2Model.forward*], contendo os tensores brutos do featurizer. Em seguida, `EsmFold2Model._prepare_features` aplica codificação one-hot aos campos categóricos e zera o padding, e `forward` substitui esses valores usando *dataclasses.replace*, de modo que todos os consumidores a jusso desse ponto vejam as formas codificadas documentadas abaixo. Retornado em [*EsmFold2TrunkOutput*] para que o amostrador de difusão e a cabeça de confiança reutilizem a featurização do tronco, em vez de refazê-la.

Uma dataclass simples em vez de um *~utils.ModelOutput*: todos os campos aqui são obrigatórios e são lidos incondicionalmente a jusante, e o `ModelOutput` permite no máximo um campo obrigatório (os demais devem ter valor padrão `None`), o que transformaria a ausência de um tensor de um erro de construtor em um `None` que surgiria profundamente no codificador de átomos.