# ESMFold2

## Resumen

ESMFold2 es un modelo de predicción de estructura proteica de todos los átomos. Predice coordenadas 3D y la confianza por residuo (pLDDT, PAE, PDE) directamente a partir de una secuencia de aminoácidos, utilizando el modelo de lenguaje proteico [ESMC](./esmc) como su esqueleto. La arquitectura combina un codificador de átomos con ventana deslizante y embeddings de posición rotacional 3D, un tronco de plegamiento por pares aplicado de forma iterativa, una cabeza de estructura basada en difusión y una cabeza de confianza.

El punto de control del modelo está disponible en el Hugging Face Hub en [`biohub/ESMFold2`](https://huggingface.co/biohub/ESMFold2).

## Ejemplo 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` devuelve las salidas sin procesar (coordenadas de átomos, logits del distograma y métricas de confianza) como un [EsmFold2Output](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output) si las necesitas en lugar de una cadena PDB. Es posible que obtengas predicciones ligeramente diferentes si ejecutas la misma secuencia varias veces. Establece una semilla manual si deseas estructuras exactamente reproducibles.

ESMFold2 genera `config.structure_head.num_diffusion_samples` estructuras por plegamiento. `infer_protein_as_pdb` representa la mejor clasificada (con el pTM más alto); pase `sample_idx` para seleccionar una muestra específica. El PDB incluye el pLDDT por residuo en la columna de b-factor, en la misma escala de 0 a 1 que la salida de `plddt`.

### `forward` frente a `fold`

La predicción de estructura tiene dos partes. `EsmFold2Model.forward` es la primera: ejecuta el tronco de plegamiento sobre las entradas featurizadas y devuelve la representación de pares refinada junto con el distograma, como un [EsmFold2TrunkOutput](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput). No produce coordenadas 3D: ESMFold2 las obtiene mediante un denoising iterativo, y ese bucle de muestreo (el schedule de ruido, la alineación de Kabsch y la actualización ODE/SDE) se encuentra en `EsmFold2FoldingMixin`, junto con la llamada a la cabeza de confianza:

| Método | Úsalo para |
| --- | --- |
| `infer_protein_as_pdb(sequence)` | una cadena PDB, directamente de una secuencia de aminoácidos |
| `infer_protein(sequence)` | la salida cruda [EsmFold2Output](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.models.esmfold2.modeling_esmfold2.EsmFold2Output) |
| `fold(**features)` | entradas preprocesadas (lo que `infer_protein` llama) |
| `forward(**features)` | el tronco por sí solo: una distogram y una representación de pares, sin muestreo |

Llame a `fold` o `infer_protein` para obtener una estructura real. Recurra a `forward` cuando solo necesite el distograma o cuando desee controlar usted mismo el muestreador de difusión: `fold` llama a `forward` una vez y luego pasa su salida a `EsmFold2DiffusionModule`, cuyo propio `forward` es el único paso de desruido.

## Inferencia más rápida con un kernel fusionado

El coste dominante del maletero plegable es la actualización de multiplicación de triángulos. Pasar `use_kernels=True` a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) lo sustituye por un kernel de Triton fusionado que se carga desde el Hub a través de la biblioteca [`kernels`](https://github.com/huggingface/kernels), sin alterar la predicción. Es exclusivo para inferencia y para CUDA; en CPU o si el kernel no está instalado, el modelo recurre de forma transparente a la implementación pura de PyTorch. Asegúrese de que el modelo está en un dispositivo CUDA cuando se produzca la kernelización (p. ej. con `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)
```

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

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado 384) : Ancho de representación única.

pairwise_hidden_size (`int`, *opcional*, valor predeterminado 256) : Ancho de la representación por pares.

single_inputs_size (`int`, *opcional*, valor predeterminado 451) : Ancho de las características de entrada única concatenadas que se alimentan al tronco y a la condición de difusión: `atom_encoder.output_dim` más dos one-hots de tipo de residuo y el escalar de perfil.

pair_transition_intermediate_size (`int`, *opcional*, valor predeterminado 1024) : Ancho de SwiGLU de las transiciones de pares de flujos.

sliding_window (`int`, *opcional*, valor predeterminado 128) : Tamaño de la ventana deslizante (distancia en índices de tokens) para la atención de pila de átomos, como el ancho total de la ventana en lugar del radio.

chunk_size (`int`, *opcional*, valor predeterminado 64) : Tamaño de bloque para las operaciones de pares/flujo MSA con alto consumo de memoria. `None` deshabilita el uso de bloques.

num_relative_residx_bins (`int`, *opcional*, valor predeterminado 32) : Número de bins de índice de residuo relativo en la codificación de posición relativa.

num_relative_chain_bins (`int`, *opcional*, valor predeterminado 2) : Número de bins de índice de cadena relativo en la codificación de posición relativa.

num_loops (`int`, *opcional*, valor predeterminado 10) : Número de bucles de refinamiento del tronco.

num_res_types (`int`, *opcional*, valor predeterminado 33) : Número de tipos de residuos.

max_atomic_number (`int`, *opcional*, valor predeterminado 128) : Tamaño del elemento one-hot en las características del átomo.

char_vocab_size (`int`, *opcional*, valor predeterminado 64) : Tamaño del vocabulario de caracteres para los nombres de átomos codificados.

max_chars (`int`, *opcional*, valor predeterminado 4) : Número de caracteres por nombre de átomo codificado.

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

atom_feature_dim (`int`, *opcional*) : Ancho de la característica atómica: xyz, carga y máscara, más los one-hots de elemento y caracteres del nombre del átomo. Se deriva de `max_atomic_number`, `char_vocab_size` y `max_chars` si no se establecen.

folding_trunk_num_hidden_layers (`int`, *opcional*, valor predeterminado 24) : Número de bloques de actualización de pares en el tronco de plegado.

parcae_num_coda_layers (`int`, *opcional*, valor predeterminado 2) : Número de bloques de actualización de pares en la coda de parcae.

atom_encoder (`EsmFold2AtomEncoderConfig`, *opcional*) : Configuración para el codificador de átomos SWA del incrustador de entradas.

structure_head (`EsmFold2StructureHeadConfig`, *opcional*) : Configuración para la cabeza de predicción de estructura por difusión (contiene la subconfiguración `diffusion_module`).

confidence_head (`EsmFold2ConfidenceHeadConfig`, *opcional*) : Configuración para la cabeza de confianza.

msa_encoder (`EsmFold2MsaEncoderConfig`, *opcional*) : Configuración del codificador MSA.

lm_encoder (`EsmFold2LmEncoderConfig`, *opcional*) : Configuración del codificador de estados ocultos del modelo de lenguaje.

esmc_config ([EsmcConfig](/docs/transformers/v5.23.0/es/model_doc/esmc#transformers.EsmcConfig), *opcional*) : Configuración para el backbone ESMC integrado.

Esta es la clase de configuración para almacenar la configuración de un Esmfold2Model. Se utiliza para instanciar un modelo Esmfold2 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [biohub/ESMFold2](https://huggingface.co/biohub/ESMFold2)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

```python
validate_architecture()
```

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

Comprueba las relaciones de ancho que abarcan subconfiguraciones; cada subconfiguración comprueba las suyas.

## EsmFold2PreTrainedModel[[transformers.EsmFold2PreTrainedModel]]

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

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

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

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

## EsmFold2Model[[transformers.EsmFold2Model]]

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

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

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

**Parámetros:**

config ([EsmFold2Config](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.EsmFold2Config)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

ESMFold2, un predictor de estructura proteica de todos los átomos con un backbone de modelo de lenguaje proteico ESMC integrado. Esta es la arquitectura estándar de ESMFold2 publicada, cuyo tronco es una pila recurrente lineal (referida internamente como "parcae").

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/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 del complejo completo; alimenta la codificación de posición relativa.

residue_index (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Índice de residuo dentro de cada cadena; alimenta la codificación de posición relativa.

asym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de unidad asimétrica (cadena) para cada token.

sym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de copia simétrica que distingue cadenas idénticas de un homómero.

entity_id (*torch.Tensor* de forma *(batch_size, num_tokens)*) : ID de entidad que agrupa los tokens que pertenecen a la misma entidad 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` = ADN, `2` = ARN, `3` = no polímero (ligando).

res_type (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Índice de tipo residuo (identidad de aminoácido) para cada token.

token_bonds (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, 1)*) : Característica de enlace covalente entre pares de tokens.

attention_mask (*torch.Tensor* de forma *(batch_size, num_tokens)*) : Máscara que marca los tokens válidos (`1`) frente al relleno (`0`). Las entradas deben estar rellenas a la derecha.

atom_inputs (*~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs*) : Los tensores de átomos del conformero de referencia sin procesar, agrupados: posiciones, números atómicos, cargas formales, nombres de átomos codificados, IDs de grupo por átomo, la máscara de relleno de átomos y el mapa de átomo->token.

deletion_mean (*torch.Tensor* de forma *(batch_size, num_tokens)*, *opcional*) : Número medio de eliminaciones de MSA por columna. El valor predeterminado es cero (sin MSA).

msa (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Tokens de tipo de residuo de MSA (la fila 0 es la secuencia de consulta). El valor predeterminado es una MSA de secuencia única.

has_deletion (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Bandera booleana que marca las posiciones de MSA precedidas por una eliminación.

deletion_value (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Conteos de eliminación de MSA por posición.

msa_attention_mask (*torch.Tensor* de forma *(batch_size, msa_depth, num_tokens)*, *opcional*) : Máscara de validez para las filas/columnas de la MSA.

input_ids (*torch.Tensor* de forma *(batch_size, num_tokens)*, *opcional*) : ids de tokens del vocabulario ESMC para la secuencia. Se alimenta al backbone ESMC integrado para producir *lm_hidden_states* cuando estos no se pasan directamente; se ignora cuando se proporciona *lm_hidden_states*.

lm_hidden_states (*torch.Tensor* de forma *(batch_size, num_tokens, num_esmc_layers + 1, esmc_hidden_size)*, *opcional*) : Estados ocultos precalculados del backbone de ESMC, uno por cada capa del backbone más las incrustaciones. Cuando se proporcionan, el backbone no se ejecuta y *input_ids* no se utiliza.

num_loops (*int*, *optional*) : Número de bucles de refinamiento del tronco. El valor predeterminado es *config.num_loops*.

**Devuelve:** [*~models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput*] o *tuple(torch.Tensor)*

Un [*~models.esmfold2.modeling_esmfold2.EsmFold2TrunkOutput*] o una tupla de *torch.Tensor* (si se pasa *return_dict=False* o cuando *config.return_dict=False*) que comprende varios elementos según la configuración ([*EsmFold2Config*]) y las entradas.

Ejecute el tronco de plegamiento: extraiga las características de las entradas, incruste las en una representación de pares, refínela a lo largo de *num_loops* iteraciones de reciclaje y lea el distograma. Esta es la mitad determinista de la predicción de estructura; el muestreador de difusión que convierte la representación de pares devuelta en coordenadas 3D se encuentra en *EsmFold2FoldingMixin*: llame a [*~EsmFold2Model.fold*] o [*~EsmFold2Model.infer_protein*] para una predicción de extremo a extremo.

- **distogram_logits** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, distogram_bins)*) -- Logits de la distribución de distancias predicha sobre pares de residuos.
- **pair_states** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- La representación final de pares del tronco, en fp32.
- **single_inputs** (*torch.Tensor* de forma *(batch_size, num_tokens, single_inputs_size)*) -- Características de entrada única concatenadas construidas por el incrustador de entradas.
- **relative_position_encoding** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- Codificación de pares de posición relativa.
- **token_bonds_encoding** (*torch.Tensor* de forma *(batch_size, num_tokens, num_tokens, pairwise_hidden_size)*) -- Característica de enlace covalente entre tokens incrustada.
- **atom_inputs** (*~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs*, *opcional*) -- Las entradas de átomos del conformero de referencia con características, reutilizadas por la pila de átomos de difusión.

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

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

Predice una estructura de extremo a extremo a partir de entradas con características: ejecuta el tronco (*EsmFold2Model.forward*, que documenta los argumentos de las características), muestrea coordenadas desde la cabeza de estructura de difusión y las puntúa con la cabeza de confianza.

Aquí solo se nombran los argumentos que necesitan el muestreador y la cabeza de confianza; el resto se reenvía al tronco sin modificaciones, por lo que `fold` toma los mismos argumentos que `forward`.

attention_mask (*torch.Tensor* de forma *(batch_size, num_tokens)*): Máscara que marca los tokens válidos (`1`) frente al relleno (`0`). También se reenvía al tronco. asym_id (*torch.Tensor* de forma *(batch_size, num_tokens)*): ID de unidad asimétrica (cadena) para cada token. También se reenvía al 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` = ADN, `2` = ARN, `3` = no polímero (ligando). También se reenvía al tronco. distogram_atom_idx (*torch.Tensor* de forma *(batch_size, num_tokens)*): Índice del átomo representativo (Cβ, o Cα para la glicina) de cada token. Lo utiliza la cabeza de confianza; el tronco no lo necesita. num_diffusion_samples (*int*, *opcional*): Número de muestras de estructura paralelas que se deben extraer; la cabeza de confianza se vuelve a ejecutar una vez por muestra. El valor predeterminado es *config.structure_head.num_diffusion_samples*. num_sampling_steps (*int*, *opcional*): Número de pasos de muestreo de difusión. El valor predeterminado es *config.structure_head.inference_num_steps*. trunk_kwargs: Las entradas restantes con características (*num_loops* incluido, además de los tensores crudos por átomo agrupados a continuación en *atom_inputs*), reenviados a [*EsmFold2Model.forward*], que los documenta.

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

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

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

Extrae las características de `sequence` y pliega la secuencia. `forward_kwargs` se pasa a [*~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)
```

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

Doblar `sequence` y renderizar la predicción como una cadena PDB.

`sample_idx` selecciona qué muestra de difusión se debe renderizar; por defecto, la de mejor clasificación.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/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 de la distribución de distancias predicha sobre pares de residuos (independiente del RNG; sin muestreo de difusión).

sample_atom_coords (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms, 3)`) : Coordenadas cartesianas de todos los átomos predichas para cada muestra de difusión.

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

plddt (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens)`) : Confianza lDDT predicha por residuo.

plddt_per_atom (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms)`) : Confianza lDDT predicha por átomo.

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

complex_plddt (`torch.Tensor` de forma `(num_diffusion_samples,)`) : pLDDT medio sobre todos los átomos del complejo.

complex_iplddt (`torch.Tensor` de forma `(num_diffusion_samples,)`) : pLDDT complejo ponderado por interfaz.

pae_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens, num_pae_bins)`) : Logits de los bins de error alineado predicho.

pae (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens)`) : Error alineado predicho esperado (Å) para cada par de residuos.

pde_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens, num_pde_bins)`) : Logits de los bins de error de distancia predicha.

pde (`torch.Tensor` de forma `(num_diffusion_samples, num_tokens, num_tokens)`) : Error de distancia predicho esperado (Å) para cada par de residuos.

resolved_logits (`torch.Tensor` de forma `(num_diffusion_samples, num_atoms, 2)`) : Logits resueltos/no resueltos por átomo.

ptm (`torch.Tensor` de forma `(num_diffusion_samples,)`) : Puntuación TM predicha para cada muestra.

iptm (`torch.Tensor` de forma `(num_diffusion_samples,)`) : Puntuación TM de la interfaz predicha para cada muestra.

pair_chains_iptm (`torch.Tensor` de forma `(num_diffusion_samples, num_chains, num_chains)`) : Puntuación TM de interfaz predicha para cada par ordenado de cadenas.

Salida de [EsmFold2Model](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.EsmFold2Model). Todas las puntuaciones de confianza están en una escala de 0 a 1; los tensores por muestra tienen un eje 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/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 de la distribución de distancias predicha sobre pares de residuos.

pair_states (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : La representación final de pares del tronco, en fp32.

single_inputs (`torch.Tensor` de forma `(batch_size, num_tokens, single_inputs_size)`) : Características de entrada única concatenadas construidas por el integrador de entradas.

relative_position_encoding (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : Codificación de pares de posición relativa.

token_bonds_encoding (`torch.Tensor` de forma `(batch_size, num_tokens, num_tokens, pairwise_hidden_size)`) : Característica de enlace covalente inter-token embebida.

atom_inputs (`~models.esmfold2.modeling_esmfold2.EsmFold2AtomInputs`, *opcional*) : Las entradas de átomos del conformero de referencia con características, reutilizadas por la pila de átomos de difusión.

Salida de [EsmFold2Model.forward()](/docs/transformers/v5.23.0/es/model_doc/esmfold2#transformers.EsmFold2Model.forward): la representación de pares del tronco de plegamiento, el distograma leído a partir de ella y los tensores de condicionamiento que consumen las cabezas de estructura y confianza. Todo en este punto es determinista a partir de las entradas, salvo el estado inicial aleatorio de pares del 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)
```

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

**Parámetros:**

ref_pos : *(batch_size, num_atoms, 3)* coordenadas cartesianas del conformero de referencia.

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

atom_attention_mask : *(batch_size, num_atoms)* átomos válidos (*1*) frente a relleno (*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)* nombre de átomo one-hot.

ref_space_uid : *(batch_size, num_atoms)* ID de grupo por átomo (el índice de token del átomo).

atom_to_token : *(batch_size, num_atoms)* índice del token al que pertenece cada átomo.

Entradas de átomos del conformero de referencia con características, agrupadas para que la pila de átomos tome un solo argumento.

Recibido como un único argumento por [*EsmFold2Model.forward*], contiene los tensores crudos del featurizer. A continuación, `EsmFold2Model._prepare_features` codifica en one-hot los campos categóricos y pone a cero el padding, y `forward` los sustituye mediante *dataclasses.replace*, de modo que todos los consumidores aguas abajo de ese punto ven las formas codificadas documentadas a continuación. Se devuelve en [*EsmFold2TrunkOutput*] para que el muestreador de difusión y la cabeza de confianza reutilicen la featurización del tronco en lugar de repetirla.

Una clase de datos simple en lugar de una *~utils.ModelOutput*: todos los campos aquí son obligatorios y se leen de forma incondicional aguas abajo, y `ModelOutput` permite como máximo un campo obligatorio (el resto debe tener un valor predeterminado de `None`), lo que convertiría un tensor ausente de un error de constructor en un `None` que aparece en las profundidades del codificador de átomos.

