# ChronoEditTransformer3DModel

Un modèle Diffusion Transformer pour des données vidéo 3D, issu de [ChronoEdit: Towards Temporal Reasoning for Image Editing and World Simulation](https://huggingface.co/papers/2510.04290) de NVIDIA et de l’Université de Toronto, par Jay Zhangjie Wu, Xuanchi Ren, Tianchang Shen, Tianshi Cao, Kai He, Yifan Lu, Ruiyuan Gao, Enze Xie, Shiyi Lan, Jose M. Alvarez, Jun Gao, Sanja Fidler, Zian Wang, Huan Ling.

> **En bref :** ChronoEdit reformule l'édition d'images comme une tâche de génération de vidéo, en utilisant les images d'entrée et éditées comme images de début et de fin afin d'exploiter les modèles de vidéo préentraînés avec une cohérence temporelle. Une étape de raisonnement temporel introduit des jetons de raisonnement pour garantir des édictions physiquement plausibles et visualiser la trajectoire d'édition.

Le modèle peut être chargé à l'aide du fragment de code suivant.

```python
from diffusers import ChronoEditTransformer3DModel

transformer = ChronoEditTransformer3DModel.from_pretrained("nvidia/ChronoEdit-14B-Diffusers", subfolder="transformer", dtype=torch.bfloat16)
```

## ChronoEditTransformer3DModel[[diffusers.ChronoEditTransformer3DModel]]

#### diffusers.ChronoEditTransformer3DModel[[diffusers.ChronoEditTransformer3DModel]]

```python
diffusers.ChronoEditTransformer3DModel(patch_size: tuple[int] = (1, 2, 2), num_attention_heads: int = 40, attention_head_dim: int = 128, in_channels: int = 16, out_channels: int = 16, text_dim: int = 4096, freq_dim: int = 256, ffn_dim: int = 13824, num_layers: int = 40, cross_attn_norm: bool = True, qk_norm: str | None = 'rms_norm_across_heads', eps: float = 1e-06, image_dim: int | None = None, added_kv_proj_dim: int | None = None, rope_max_seq_len: int = 1024, pos_embed_seq_len: int | None = None, rope_temporal_skip_len: int = 8)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_chronoedit.py#L523)

**Paramètres :**

patch_size (`tuple[int]`, par défaut `(1, 2, 2)`) : dimensions des patches 3D pour l'intégration vidéo (t_patch, h_patch, w_patch).

num_attention_heads (`int`, par défaut `40`) : Longueur fixe pour les embeddings de texte.

attention_head_dim (`int`, par défaut `128`) : Le nombre de canaux dans chaque tête.

in_channels (`int`, par défaut `16`) : Le nombre de canaux dans l'entrée.

out_channels (`int`, par défaut `16`) : Le nombre de canaux dans la sortie.

text_dim (`int`, par défaut `512`) : Dimension d'entrée pour les embeddings de texte.

freq_dim (`int`, par défaut `256`) : Dimension pour les embeddings temporels sinusoïdaux.

ffn_dim (`int`, par défaut `13824`) : Dimension intermédiaire du réseau feed-forward.

num_layers (`int`, par défaut `40`) : Le nombre de blocs de transformeurs à utiliser.

window_size (`tuple[int]`, par défaut `(-1, -1)`) : Taille de la fenêtre pour l'attention locale (-1 indique une attention globale).

cross_attn_norm (`bool`, par défaut `True`) : Active la normalisation de l'attention croisée.

qk_norm (`bool`, par défaut `True`) : Active la normalisation des requêtes/clés.

eps (`float`, par défaut `1e-6`) : Valeur d'épsilon pour les couches de normalisation.

add_img_emb (`bool`, par défaut `False`) : Indique s'il faut utiliser img_emb.

added_kv_proj_dim (`int`, *facultatif*, par défaut `None`) : Le nombre de canaux à utiliser pour les projections de clé et de valeur ajoutées. Si `None`, aucune projection n'est utilisée.

Un modèle Transformer pour des données de type vidéo utilisé dans le modèle ChronoEdit.

#### forward[[diffusers.ChronoEditTransformer3DModel.forward]]

```python
forward(hidden_states: Tensor, timestep: LongTensor, encoder_hidden_states: Tensor, encoder_hidden_states_image: typing.Optional[torch.Tensor] = None, return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_chronoedit.py#L644)

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, num_channels, num_frames, height, width)`) : `hidden_states` d'entrée.

timestep (`torch.LongTensor`) : Utilisé pour indiquer l'étape de débruitage.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, sequence_len, embed_dims)`) : Embeddings conditionnels (embeddings calculés à partir des conditions d'entrée telles que les prompts) à utiliser.

encoder_hidden_states_image (`torch.Tensor`, *facultatif*) : Incrustations d’images conditionnelles pour la génération conditionnée par image.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.transformer_2d.Transformer2DModelOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

**Retourne :**

Si `return_dict` est True, un `~models.transformer_2d.Transformer2DModelOutput` est renvoyé, sinon un `tuple` dont le premier élément est le tenseur d'échantillon.

La méthode forward du [ChronoEditTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/chronoedit_transformer_3d#diffusers.ChronoEditTransformer3DModel).

## Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

#### diffusers.models.modeling_outputs.Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

```python
diffusers.models.modeling_outputs.Transformer2DModelOutput(sample: torch.Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_outputs.py#L21)

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/transformer2d#diffusers.Transformer2DModel) est discret) : Les états cachés en sortie, conditionnés par l'entrée `encoder_hidden_states`. Si discret, renvoie les distributions de probabilité pour les pixels latents non bruités.

La sortie de [Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/transformer2d#diffusers.Transformer2DModel).