diffusers/main/fr/api/models/consisid_transformer3d.md

ConsisIDTransformer3DModel

Un modèle Diffusion Transformer pour des données 3D issu de ConsisID a été introduit dans Identity-Preserving Text-to-Video Generation by Frequency Decomposition par l'Université de Pékin & l'Université de Rochester & d'autres.

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

from diffusers import ConsisIDTransformer3DModel

transformer = ConsisIDTransformer3DModel.from_pretrained("BestWishYsh/ConsisID-preview", subfolder="transformer", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

ConsisIDTransformer3DModel[[diffusers.ConsisIDTransformer3DModel]]

diffusers.ConsisIDTransformer3DModel[[diffusers.ConsisIDTransformer3DModel]]

diffusers.ConsisIDTransformer3DModel(num_attention_heads: int = 30, attention_head_dim: int = 64, in_channels: int = 16, out_channels: int | None = 16, flip_sin_to_cos: bool = True, freq_shift: int = 0, time_embed_dim: int = 512, text_embed_dim: int = 4096, num_layers: int = 30, dropout: float = 0.0, attention_bias: bool = True, sample_width: int = 90, sample_height: int = 60, sample_frames: int = 49, patch_size: int = 2, temporal_compression_ratio: int = 4, max_text_seq_length: int = 226, activation_fn: str = 'gelu-approximate', timestep_activation_fn: str = 'silu', norm_elementwise_affine: bool = True, norm_eps: float = 1e-05, spatial_interpolation_scale: float = 1.875, temporal_interpolation_scale: float = 1.0, use_rotary_positional_embeddings: bool = False, use_learned_positional_embeddings: bool = False, is_train_face: bool = False, is_kps: bool = False, cross_attn_interval: int = 2, cross_attn_dim_head: int = 128, cross_attn_num_heads: int = 16, LFE_id_dim: int = 1280, LFE_vit_dim: int = 1024, LFE_depth: int = 10, LFE_dim_head: int = 64, LFE_num_heads: int = 16, LFE_num_id_token: int = 5, LFE_num_querie: int = 32, LFE_output_dim: int = 2048, LFE_ff_mult: int = 4, LFE_num_scale: int = 5, local_face_scale: float = 1.0)

Source

Paramètres :

num_attention_heads (int, par défaut 30) : Le nombre de têtes à utiliser pour l'attention multi-têtes.

attention_head_dim (int, par défaut 64) : 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, facultatif, par défaut 16) : Le nombre de canaux dans la sortie.

flip_sin_to_cos (bool, par défaut True) : Indique s'il faut inverser le sin en cos dans l'encodage temporel.

time_embed_dim (int, par défaut 512) : Dimension de sortie des embeddings de pas de temps.

text_embed_dim (int, par défaut 4096) : Dimension d'entrée des embeddings de texte issus de l'encodeur de texte.

num_layers (int, par défaut 30) : Le nombre de blocs Transformer à utiliser.

dropout (float, par défaut 0.0) : La probabilité de dropout à utiliser.

attention_bias (bool, par défaut True) : Indique s'il faut utiliser un biais dans les couches de projection d'attention.

sample_width (int, par défaut 90) : La largeur des latents d'entrée.

sample_height (int, par défaut 60) : La hauteur des latents d'entrée.

sample_frames (int, par défaut 49) : Le nombre de frames dans les latents d'entrée. Notez que ce paramètre a été initialisé à tort à 49 au lieu de 13, car ConsisID traitait 13 frames latentes à la fois dans ses réglages par défaut et recommandés, mais ne peut pas être modifié pour la valeur correcte afin de garantir la rétrocompatibilité. Pour créer un transformer avec K frames latentes, la valeur correcte à passer ici serait : ((K - 1) * temporal_compression_ratio + 1).

patch_size (int, par défaut 2) : La taille des patches à utiliser dans la couche d'encodage de patches.

temporal_compression_ratio (int, par défaut 4) : Le ratio de compression le long de la dimension temporelle. Consultez la documentation de sample_frames.

max_text_seq_length (int, par défaut 226) : La longueur de séquence maximale des embeddings de texte en entrée.

activation_fn (str, par défaut "gelu-approximate") : Fonction d'activation à utiliser dans le réseau de neurones à propagation avant.

timestep_activation_fn (str, par défaut "silu") : Fonction d'activation à utiliser lors de la génération des embeddings de pas de temps.

norm_elementwise_affine (bool, par défaut True) : Indique s'il faut utiliser une transformation affine élément par élément dans les couches de normalisation.

norm_eps (float, par défaut 1e-5) : La valeur epsilon à utiliser dans les couches de normalisation.

spatial_interpolation_scale (float, par défaut 1.875) : Facteur d'échelle à appliquer aux embeddings positionnels 3D sur les dimensions spatiales.

temporal_interpolation_scale (float, par défaut 1.0) : Facteur d'échelle à appliquer aux embeddings positionnels 3D le long des dimensions temporelles.

is_train_face (bool, par défaut False) : Indique s'il faut activer le module de préservation de l'identité pendant le processus d'entraînement. Si défini sur True, le modèle se concentrera sur les tâches de préservation de l'identité.

is_kps (bool, par défaut False) : Indique s'il faut activer les points clés pour l'extracteur facial global. Si True, les points clés seront présents dans le modèle.

cross_attn_interval (int, par défaut 2) : L'intervalle entre les couches d'attention croisée dans l'architecture Transformer. Une valeur plus élevée peut réduire la fréquence des calculs d'attention croisée, ce qui peut aider à diminuer la surcharge de calcul.

cross_attn_dim_head (int, optionnel, par défaut 128) : La dimension de chaque tête d'attention dans les couches d'attention croisée de l'architecture Transformer. Une valeur plus élevée augmente la capacité à traiter des motifs plus complexes, mais accroît également les coûts mémoire et de calcul.

cross_attn_num_heads (int, optionnel, par défaut 16) : Le nombre de têtes d'attention dans les couches d'attention croisée. Un plus grand nombre de têtes permet des mécanismes d'attention plus parallèles, capturant des relations diverses entre les différents composants de l'entrée, mais peut également augmenter les exigences de calcul.

LFE_id_dim (int, optionnel, par défaut 1280) : La dimensionnalité du vecteur d'identité utilisé dans le Local Facial Extractor (LFE). Ce vecteur représente les caractéristiques d'identité d'un visage, essentielles pour des tâches telles que la reconnaissance faciale et la préservation de l'identité à travers différentes images.

LFE_vit_dim (int, optionnel, par défaut 1024) : La dimension de la sortie du vision transformer (ViT) utilisée dans le Local Facial Extractor (LFE). Cette valeur détermine la taille des vecteurs de caractéristiques générés par le transformer qui seront traités pour l'extraction des caractéristiques faciales.

LFE_depth (int, optionnel, par défaut 10) : Le nombre de couches dans le Local Facial Extractor (LFE). Augmenter la profondeur permet au modèle de capturer des représentations plus complexes des traits du visage, mais augmente également la charge de calcul.

LFE_dim_head (int, optionnel, par défaut 64) : La dimension de chaque tête d'attention dans le Local Facial Extractor (LFE). Ce paramètre influence la finesse avec laquelle le modèle peut traiter et se concentrer sur différentes parties des traits du visage lors du processus d'extraction.

LFE_num_heads (int, optionnel, par défaut 16) : Le nombre de têtes d'attention dans le Local Facial Extractor (LFE). Un nombre plus élevé de têtes peut améliorer la capacité du modèle à capturer des caractéristiques faciales variées, mais au prix d'une complexité computationnelle accrue.

LFE_num_id_token (int, optionnel, par défaut 5) : Le nombre de jetons d'identité utilisés dans l'extracteur facial local (LFE). Cela définit le nombre de jetons liés à l'identité que le modèle traitera pour garantir la préservation de l'identité du visage lors de l'extraction des caractéristiques.

LFE_num_querie (int, optionnel, par défaut 32) : Le nombre de jetons de requête utilisés dans le Local Facial Extractor (LFE). Ces jetons servent à capturer les informations faciales à haute fréquence qui aident à une extraction précise des traits du visage.

LFE_output_dim (int, optionnel, par défaut 2048) : La dimension de sortie du Local Facial Extractor (LFE). Cette dimension détermine la taille des vecteurs de caractéristiques produits par le module LFE, qui seront utilisés pour des tâches ultérieures telles que la reconnaissance faciale ou le suivi.

LFE_ff_mult (int, optionnel, par défaut 4) : Le facteur de multiplication appliqué à la taille de la couche cachée du réseau feed-forward dans le Local Facial Extractor (LFE). Une valeur plus élevée augmente la capacité du modèle à apprendre des transformations de traits faciaux plus complexes, mais augmente également les exigences en calcul et en mémoire.

LFE_num_scale (int, optionnel, par défaut 5) : Le nombre d'échelles différentes pour les caractéristiques visuelles. Une valeur plus élevée augmente la capacité du modèle à apprendre des transformations plus complexes des traits du visage, mais augmente également les exigences en calcul et en mémoire.

local_face_scale (float, par défaut 1.0) : Un facteur d'échelle utilisé pour ajuster l'importance des traits faciaux locaux dans le modèle. Cela peut influencer la force avec laquelle le modèle se concentre sur le contenu facial à haute fréquence.

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

forward[[diffusers.ConsisIDTransformer3DModel.forward]]

forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: typing.Union[int, float, torch.LongTensor], timestep_cond: typing.Optional[torch.Tensor] = None, image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None, attention_kwargs: dict[str, typing.Any] | None = None, id_cond: typing.Optional[torch.Tensor] = None, id_vit_hidden: typing.Optional[torch.Tensor] = None, return_dict: bool = True)

Source

Paramètres :

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

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.

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

timestep_cond (torch.Tensor, facultatif) : Incrustations conditionnelles pour le pas de temps. Si fournies, les incrustations seront additionnées aux échantillons passés par la couche self.time_embedding pour obtenir les incrustations finales du pas de temps.

image_rotary_emb (tuple de torch.Tensor, facultatif) : Incrustations positionnelles rotatives précalculées.

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.

id_cond (torch.Tensor, facultatif) : L'embedding de visage extrait par l'extracteur facial local, utilisé pour le conditionnement d'identité.

id_vit_hidden (torch.Tensor, facultatif) : Les états cachés de ViT extraits des images de visage, utilisés pour le conditionnement d'identité.

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

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 ConsisIDTransformer3DModel.

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

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

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

Source

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 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.