# OmniGenTransformer2DModel Un modèle Transformer qui accepte des instructions multimodales pour générer des images pour [OmniGen](https://github.com/VectorSpaceLab/OmniGen/). L'abstract de l'article est : *L’émergence des grands modèles de langage (LLM) a unifié les tâches de génération de langage et révolutionné l’interaction homme-machine. Cependant, dans le domaine de la génération d’images, un modèle unifié capable de gérer diverses tâches au sein d’un seul cadre reste largement inexploré. Dans ce travail, nous présentons OmniGen, un nouveau modèle de diffusion pour la génération d’images unifiée. OmniGen se caractérise par les fonctionnalités suivantes : 1) Unification : OmniGen ne démontre pas seulement des capacités de génération d’images à partir de texte, mais prend également en charge de manière inhérente diverses tâches en aval, telles que l’édition d’images, la génération pilotée par un sujet et la génération conditionnelle visuelle. 2) Simplicité : L’architecture d’OmniGen est hautement simplifiée, éliminant le besoin de plugins supplémentaires. De plus, par rapport aux modèles de diffusion existants, il est plus convivial et peut accomplir des tâches complexes de bout en bout via des instructions, sans avoir besoin d’étapes intermédiaires supplémentaires, simplifiant ainsi considérablement le flux de travail de génération d’images. 3) Transfert de connaissances : Grâce à l’apprentissage dans un format unifié, OmniGen transfère efficacement les connaissances entre différentes tâches, gère les tâches et les domaines inconnus et présente des capacités novatrices. Nous explorons également les capacités de raisonnement du modèle et les applications potentielles du mécanisme de chaîne de pensée. Ce travail représente la première tentative de créer un modèle de génération d’images à usage général, et nous publierons nos ressources sur https://github.com/VectorSpaceLab/OmniGen pour favoriser les avancées futures.* ```python import torch from diffusers import OmniGenTransformer2DModel transformer = OmniGenTransformer2DModel.from_pretrained("Shitao/OmniGen-v1-diffusers", subfolder="transformer", dtype=torch.bfloat16) ``` ## OmniGenTransformer2DModel[[diffusers.OmniGenTransformer2DModel]] #### diffusers.OmniGenTransformer2DModel[[diffusers.OmniGenTransformer2DModel]] ```python diffusers.OmniGenTransformer2DModel(in_channels: int = 4, patch_size: int = 2, hidden_size: int = 3072, rms_norm_eps: float = 1e-05, num_attention_heads: int = 32, num_key_value_heads: int = 32, intermediate_size: int = 8192, num_layers: int = 32, pad_token_id: int = 32000, vocab_size: int = 32064, max_position_embeddings: int = 131072, original_max_position_embeddings: int = 4096, rope_base: int = 10000, rope_scaling: dict = None, pos_embed_max_size: int = 192, time_step_dim: int = 256, flip_sin_to_cos: bool = True, downscale_freq_shift: int = 0, timestep_activation_fn: str = 'silu') ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_omnigen.py#L283) **Paramètres :** in_channels (`int`, par défaut `4`) : Le nombre de canaux dans l'entrée. patch_size (`int`, par défaut `2`) : La taille des patches spatiaux à utiliser dans la couche d'encodage de patches. hidden_size (`int`, par défaut `3072`) : La dimension des couches cachées du modèle. rms_norm_eps (`float`, par défaut `1e-5`) : Eps pour la couche RMSNorm. num_attention_heads (`int`, par défaut `32`) : Le nombre de têtes à utiliser pour l'attention multi-têtes. num_key_value_heads (`int`, par défaut `32`) : Le nombre de têtes à utiliser pour les clés et les valeurs dans l'attention multi-têtes. intermediate_size (`int`, par défaut `8192`) : Dimension de la couche cachée dans les couches FeedForward. num_layers (`int`, par défaut `32`) : Le nombre de blocs de transformeurs à utiliser. pad_token_id (`int`, par défaut `32000`) : L'identifiant du jeton de bourrage. vocab_size (`int`, par défaut `32064`) : La taille du vocabulaire des embeddings. rope_base (`int`, par défaut `10000`) : La valeur theta par défaut à utiliser lors de la création de RoPE. rope_scaling (`dict`, optionnel) : Les facteurs d'échelle pour RoPE. Doit contenir `short_factor` et `long_factor`. pos_embed_max_size (`int`, par défaut `192`) : La taille maximale des embeddings positionnels. time_step_dim (`int`, par défaut `256`) : Dimension de sortie des embeddings de timestep. flip_sin_to_cos (`bool`, par défaut `True`) : Indique s'il faut inverser les sin et cos dans les embeddings positionnels lors de la préparation des embeddings de pas de temps. downscale_freq_shift (`int`, par défaut `0`) : Le décalage de fréquence à utiliser lors de la réduction de l'échelle des embeddings de timestep. timestep_activation_fn (`str`, par défaut `silu`) : La fonction d'activation à utiliser pour les embeddings de pas de temps. Le modèle Transformer introduit dans OmniGen (https://huggingface.co/papers/2409.11340). #### forward[[diffusers.OmniGenTransformer2DModel.forward]] ```python forward(hidden_states: Tensor, timestep: typing.Union[int, float, torch.FloatTensor], input_ids: Tensor, input_img_latents: list, input_image_sizes: dict, attention_mask: Tensor, position_ids: Tensor, return_dict: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_omnigen.py#L407) **Paramètres :** hidden_states (`torch.Tensor` de forme `(batch_size, in_channels, height, width)`) : `hidden_states` en entrée. timestep (`torch.LongTensor`) : Utilisé pour indiquer l'étape de débruitage. input_ids (`torch.Tensor`) : Identifiants de jetons de texte multimodaux utilisés comme conditionnement. input_img_latents (`list` de `torch.Tensor`) : Liste de latents pour les images d'entrée utilisées comme conditionnement. input_image_sizes (`dict` de `int` vers `list` de `int`) : Correspondance entre l'indice d'échantillon et les positions où les embeddings d'image d'entrée doivent être placés dans la séquence de conditionnement. attention_mask (`torch.Tensor`) : Masque d'attention pour la séquence multimodale conjointe. position_ids (`torch.Tensor`) : Identifiants de position utilisés pour calculer les embeddings positionnels. 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 :** `~models.transformer_2d.Transformer2DModelOutput` ou `tuple` Si `return_dict` est True, un `~models.transformer_2d.Transformer2DModelOutput` est renvoyé, sinon un simple `tuple` est renvoyé. Méthode forward du [OmniGenTransformer2DModel](/docs/diffusers/main/fr/api/models/omnigen_transformer#diffusers.OmniGenTransformer2DModel).