Buckets:
| # PAN2Transformer3DModel | |
| Le diffusion transformer de PAN 2. Il exécute une attention conjointe sur les jetons vidéo et les jetons texte, avec des projections et des réseaux feed-forward distincts pour chaque flux. | |
| L'entrée vidéo empile les latents bruités, les latents de conditionnement et un masque de conditionnement à un canal, de sorte que le même modèle sert à la fois pour la génération de vidéo à partir de texte et pour la génération de vidéo à partir d'image. | |
| ```python | |
| import torch | |
| from diffusers import PAN2Transformer3DModel | |
| transformer = PAN2Transformer3DModel.from_pretrained("IFM/PAN2", subfolder="transformer", dtype=torch.bfloat16) | |
| ``` | |
| ## PAN2Transformer3DModel[[diffusers.PAN2Transformer3DModel]] | |
| #### diffusers.PAN2Transformer3DModel[[diffusers.PAN2Transformer3DModel]] | |
| ```python | |
| diffusers.PAN2Transformer3DModel(patch_size: tuple[int, int, int] = (1, 2, 2), in_channels: int = 97, out_channels: int = 48, num_attention_heads: int = 32, attention_head_dim: int = 128, num_layers: int = 44, num_refiner_layers: int = 4, mlp_ratio: float = 8.0, context_mlp_ratio: float = 4.0, refiner_mlp_ratio: float = 4.0, text_embed_dim: int = 4096, rope_axes_dim: tuple[int, int, int] = (16, 56, 56), rope_theta: float = 256.0, rope_temporal_scale: float = 0.6666666666666666) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_pan2.py#L325) | |
| **Paramètres :** | |
| patch_size (`tuple[int, int, int]`, par défaut `(1, 2, 2)`) : la taille de patch `(t, h, w)` de l'incorporation de patch. | |
| in_channels (`int`, par défaut `97`) : Le nombre de canaux d'entrée : latents bruités, latents de conditionnement et un canal de masque de conditionnement. | |
| out_channels (`int`, par défaut `48`) : Le nombre de canaux de sortie. | |
| num_attention_heads (`int`, par défaut `32`) : Le nombre de têtes d'attention. | |
| attention_head_dim (`int`, par défaut `128`) : Le nombre de canaux dans chaque tête d'attention. | |
| num_layers (`int`, par défaut `44`) : Le nombre de blocs d'attention conjointe. | |
| num_refiner_layers (`int`, par défaut `4`) : Le nombre de blocs de raffinement de jetons appliqués aux embeddings de texte. | |
| mlp_ratio (`float`, par défaut `8.0`) : Le ratio de la dimension interne du réseau feed-forward de la vidéo par rapport à la dimension cachée. | |
| context_mlp_ratio (`float`, par défaut `4.0`) : Le ratio de la dimension interne du réseau de propagation avant du texte par rapport à la dimension cachée. | |
| refiner_mlp_ratio (`float`, par défaut `4.0`) : Le ratio de la dimension interne du réseau de feed-forward du raffineur de jetons par rapport à la dimension cachée. | |
| text_embed_dim (`int`, par défaut `4096`) : La dimension des états cachés de l'encodeur de texte. | |
| rope_axes_dim (`tuple[int, int, int]`, par défaut `(16, 56, 56)`) : Le nombre de canaux de chaque axe `(t, h, w)` dans l'incorporation rotative. | |
| rope_theta (`float`, par défaut `256.0`) : La base de l'incorporation rotative. | |
| rope_temporal_scale (`float`, par défaut `16 / 24`) : Le facteur par lequel les positions des images de l'incorporation rotative sont multipliées : le taux d'images de référence de l'incorporation rotative sur le taux d'images des vidéos (16 sur 24 i/s). | |
| Le diffusion transformer de PAN 2. | |
| Une pile de blocs d'attention conjointe sur la concaténation des latents vidéo patchifiés et des jetons de texte affinés. L'entrée vidéo porte les latents bruités, les latents de conditionnement et un masque de conditionnement empilés le long de l'axe des canaux, de sorte que le même modèle sert à la fois pour la génération de vidéo à partir de texte et pour la génération de vidéo à partir d'image. | |
| #### forward[[diffusers.PAN2Transformer3DModel.forward]] | |
| ```python | |
| forward(hidden_states: Tensor, timestep: Tensor, encoder_hidden_states: Tensor, 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_pan2.py#L438) | |
| **Paramètres :** | |
| hidden_states (`torch.Tensor` de forme `(batch_size, in_channels, num_frames, height, width)`) : Les latents bruités, les latents de conditionnement et le masque de conditionnement, concaténés le long des canaux. | |
| timestep (`torch.Tensor` de forme `(batch_size,)`) : L'étape de débruitage dans `[0, 1000]`. | |
| encoder_hidden_states (`torch.Tensor` de forme `(batch_size, text_seq_len, text_embed_dim)`) : Les états cachés de l'encodeur de texte. | |
| attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs transmis à l'`AttentionProcessor` ; utilisé uniquement pour l'échelle LoRA. | |
| return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) plutôt qu'un simple tuple. | |
| **Retourne :** [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) ou `tuple` | |
| La vitesse prédite de forme `(batch_size, out_channels, num_frames, height, width)`. | |
| La méthode forward du [PAN2Transformer3DModel](/docs/diffusers/main/fr/api/models/pan2_transformer3d#diffusers.PAN2Transformer3DModel). | |
Xet Storage Details
- Size:
- 5.37 kB
- Xet hash:
- d52f1afa0f3d67ccee1e9c0140348979055beda9b98fedde9c0306077870dc29
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.