# RFD4ProteinaTransformer

Le débruiteur de [RFD4-Proteína](../pipelines/rfd4_proteina). Il prédit les vitesses pour les deux modalités intégrées par l'échantillonneur — les positions CA du squelette et les latents locaux par jeton — à partir de tenseurs moléculaires préparés. Les entrées sont des tenseurs nommés ainsi qu'un mappage de conditionnement dont le contenu est sélectionné par la configuration du point de contrôle ; l'analyse de la structure est hors du périmètre de cette classe.

```py
from diffusers import RFD4ProteinaTransformer

transformer = RFD4ProteinaTransformer.from_pretrained(
    "nvidia/RFD4-Proteina-Diffusers", subfolder="transformer"
)
```

## RFD4ProteinaTransformer[[diffusers.RFD4ProteinaTransformer]]

#### diffusers.RFD4ProteinaTransformer[[diffusers.RFD4ProteinaTransformer]]

```python
diffusers.RFD4ProteinaTransformer(nlayers: int = 14, token_dim: int = 768, nheads: int = 12, dim_cond: int = 256, pair_repr_dim: int = 384, latent_dim: int = 32, token_type_emb_dim: int = 32, cath_emb_dim: int = 32, t_emb_dim: int = 256, seq_sep_dim: int = 64, xt_pair_dist_dim: int = 30, xt_pair_dist_min: float = 0.1, xt_pair_dist_max: float = 3.0, feats_seq: tuple[str, ...] = ('xt_bb_ca', 'xt_local_latents', 'token_type', 'sequence_probabilities', 'cond_a37coors_nm', 'cond_a37coors_internal_nm', 'rasa_binned', 'secondary_structure', 'hbond_modernized', 'pistack', 'pication', 'saltbridge', 'hydrophobic', 'metal_coord', 'na_ss_state', 'hotspot', 'atom_charge', 'atomic_element', 'coord_group_seq', 'chirality', 'chain_centroid_xyz'), feats_cond_seq: tuple[str, ...] = ('time_emb_bb_ca', 'time_emb_local_latents', 'cath_code', 'recycle_remaining'), feats_pair_repr: tuple[str, ...] = ('xt_bb_ca_pair_dists', 'bond_mask', 'bond_order', 'is_aromatic', 'index_group_pair', 'molecule_idx_pair', 'molecule_entity_pair', 'token_bond_path_length', 'canonical_polymer_ordering', 'na_ss_pair'), feats_pair_cond: tuple[str, ...] = ('time_emb_bb_ca', 'time_emb_local_latents'), update_pair_repr_every_n: int = 2, tri_mult_c: int = 256, num_sequence_classes: int = 147, num_token_types: int = 7, recycle_conditioning_dim: int = 1)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_rfd4_proteina.py#L906)

**Paramètres :**

nlayers (`int`, par défaut `14`) : Nombre de couches du tronc.

token_dim (`int`, par défaut `768`) : Largeur de la représentation des jetons.

nheads (`int`, par défaut `12`) : Têtes d'attention par couche.

dim_cond (`int`, par défaut `256`) : Largeur du vecteur de conditionnement (temps, index de recyclage, étiquette CATH).

pair_repr_dim (`int`, par défaut `384`) : Largeur de la représentation des paires.

latent_dim (`int`, par défaut `32`) : Largeur du latent local par jeton.

token_type_emb_dim (`int`, par défaut `32`) : Largeur de l'embedding du type de jeton.

cath_emb_dim (`int`, par défaut `32`) : Largeur de chaque embedding de classe/architecture/topologie CATH.

t_emb_dim (`int`, par défaut `256`) : Largeur de l'encodage temporel sinusoïdal.

seq_sep_dim (`int`, par défaut `64`) : Nombre de classes de longueur de chemin de liaison.

xt_pair_dist_dim (`int`, par défaut `30`) : Nombre de bins de distance par paires du backbone.

xt_pair_dist_min (`float`, par défaut `0.1`), xt_pair_dist_max (`float`, par défaut `3.0`) : Plage de distance entre paires, en nanomètres.

feats_seq, feats_cond_seq, feats_pair_repr, feats_pair_cond (`list[str]`) : Noms des caractéristiques projetées dans les entrées de jeton, de conditionnement, de paire et de conditionnement de paire.

update_pair_repr_every_n (`int`, par défaut `2`) : Fréquence à laquelle la représentation des paires est mise à jour à partir des jetons entre les couches.

tri_mult_c (`int`, par défaut `256`) : Largeur cachée de la multiplication triangulaire dans ces mises à jour.

num_token_types (`int`, par défaut `7`) : Taille du vocabulaire des types de jetons : protéine, ARN, ADN, atomisé, inconnu, glycan et acide aminé non canonique.

recycle_conditioning_dim (`int`, par défaut `1`) : Largeur du one-hot `recycle_remaining`, lorsque cette fonction est présente dans `feats_cond_seq`.

num_sequence_classes (`int`, par défaut `147`) : Taille du vocabulaire de résidus que la lecture de séquence prédit.

Denoiseur de vitesse RFD4 avec modalités backbone appariées et latentes locales.

Le modèle s’exécute dans son propre dtype : chargez-le avec `dtype=torch.bfloat16` pour une inférence en précision réduite. L’état d’échantillonnage transmis à `forward` reste en float32 ; les embeddings de caractéristiques sont calculés en float32 et convertis à la projection d’entrée.

#### forward[[diffusers.RFD4ProteinaTransformer.forward]]

```python
forward(bb_ca: Tensor, local_latents: Tensor, bb_ca_time: Tensor, local_latents_time: Tensor, padding_mask: Tensor, token_type: typing.Optional[torch.Tensor] = None, atom37_mask: typing.Optional[torch.Tensor] = None, conditioning: dict[str, typing.Any] | None = None, recycle_depth: int = 0, attention_kwargs: dict[str, typing.Any] | None = None, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_rfd4_proteina.py#L1062)

**Paramètres :**

bb_ca (`torch.Tensor`) : Coordonnées bruitées du backbone `(batch, tokens, 3)` en nanomètres.

local_latents (`torch.Tensor`) : Latents locaux bruités `(batch, tokens, latent_dim)`.

bb_ca_time (`torch.Tensor`) : `(batch,)` temps du backbone dans [0, 1].

local_latents_time (`torch.Tensor`) : `(batch,)` temps local-latent dans [0, 1].

padding_mask (`torch.Tensor`) : `(batch, tokens)`, vrai là où un jeton est réel plutôt que du bourrage.

token_type (`torch.Tensor`, *facultatif*) : codes de type de jeton `(batch, tokens)`.

atom37_mask (`torch.Tensor`, *facultatif*) : `(batch, tokens, 37)`, vrai là où un emplacement d'atome est utilisé.

conditioning (`dict[str, Any]`, *facultatif*) : Les tenseurs de topologie et de conditionnement restants, sous les clés émises par le préprocesseur. Ceux qui sont lus sont fixés par les `feats_seq`, `feats_cond_seq`, `feats_pair_repr` et `feats_pair_cond` du point de contrôle ; une clé demandée par une fonctionnalité configurée mais absente laisse cette fonctionnalité non conditionnée plutôt que de lever une erreur.

recycle_depth (`int`, par défaut `0`) : Nombre de passages du tronc ; zéro exécute toujours un passage.

attention_kwargs (`dict`, *facultatif*) : Seul `scale` est lu, en tant que l'échelle LoRA pour cet appel.

return_dict (`bool`, par défaut `True`) : Retourne une sortie typée, ou un tuple de champs non nuls.

**Retourne :** `RFD4ProteinaTransformerOutput` ou `tuple`

Vitesses du backbone/latentes locales et logits de séquence/insertion optionnels, avant l'intégration du planificateur.

Prédire les vitesses à partir de tenseurs moléculaires préparés sans avancer le sampleur.

## RFD4ProteinaTransformerOutput[[diffusers.models.transformers.transformer_rfd4_proteina.RFD4ProteinaTransformerOutput]]

#### diffusers.models.transformers.transformer_rfd4_proteina.RFD4ProteinaTransformerOutput[[diffusers.models.transformers.transformer_rfd4_proteina.RFD4ProteinaTransformerOutput]]

```python
diffusers.models.transformers.transformer_rfd4_proteina.RFD4ProteinaTransformerOutput(backbone: Tensor, local_latents: typing.Optional[torch.Tensor] = None, sequence_logits: typing.Optional[torch.Tensor] = None, insertion_logits: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_rfd4_proteina.py#L890)

**Paramètres :**

backbone (`torch.Tensor`) : Vitesse du backbone de forme `(batch, tokens, 3)`, en nanomètres par unité de temps.

local_latents (`torch.Tensor`) : Vitesse latente de forme `(batch, tokens, latent_dim)`.

sequence_logits (`torch.Tensor`, *facultatif*) : Logits des résidus de forme `(batch, tokens, 147)`.

insertion_logits (`torch.Tensor`, *facultatif*) : Logits d'assignation par insertion de forme `(batch, tokens, tokens)`.

Prédictions du débruiteur avant l'intégration du planificateur.