# DiffusionGemma ## Aperçu DiffusionGemma est conçu pour réduire les goulets d'étranglement séquentiels des modèles de langage causaux standards. Il adopte une architecture encodeur-décodeur spécifiquement optimisée pour la vitesse d'inférence. L'encodeur fonctionne en mode de préremplissage, en traitant le prompt initial et en générant le cache KV. Le décodeur utilise ensuite l'attention bidirectionnelle pour traiter un bloc d'entrée (une « toile ») de jetons, en accédant au contexte mis en cache via l'attention croisée. Lors de l'inférence, DiffusionGemma exploite l'échantillonnage multi-canvas. Plutôt que de générer un jeton à la fois, le modèle débruite itérativement un bloc complet de jetons à l'aide d'un échantillonneur de diffusion. Une fois un canvas entièrement débruité, il est traité par l'encodeur et ajouté au cache KV, après quoi le modèle génère le canvas suivant. Cette approche auto-régressive par blocs permet de générer du texte à des vitesses supérieures. Vous pouvez trouver la carte du modèle et le point de contrôle [ici](https://huggingface.co/google/diffusiongemma-26B-A4B-it). Vous pouvez trouver un guide visuel du modèle [ici](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma). ## Exemples d'utilisation Bien qu’il s’agisse d’un modèle de diffusion de texte doté d’une boucle de génération personnalisée, la majeure partie de l’interface est partagée avec d’autres modèles capables de générer du texte via [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). Si vous utilisez un autre modèle `transformers` dans votre application, vous devriez pouvoir le remplacer directement par ce modèle. > [!NOTE] > DiffusionGemma est disponible à la fois dans Transformers et Diffusers, mais Diffusers en est le principal environnement. Diffusers propose l’ensemble complet des options de planification, des utilitaires de pipeline et de nouvelles fonctionnalités (planificateurs supplémentaires, critères d’arrêt, stratégies d’échantillonnage) qui n’y sont ajoutés que là-bas. Consultez le [DiffusionGemma](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) pour des exemples d’utilisation, et ouvrez un [issue](https://github.com/huggingface/diffusers/issues) sur Diffusers pour expérimenter avec différents planificateurs ou demander une fonctionnalité. L’implémentation Transformers ne reçoit que des correctifs de bogues, mais aucune nouvelle fonctionnalité. ### Limites courantes - DiffusionGemma n'accepte pas `use_cache`. Il utilise toujours un cache KV ; - La prise en charge de drapeaux courants comme `top_k` ne sera pas disponible le jour de la sortie, mais sera ajoutée au fil du temps si elle est compatible avec la diffusion de texte. ### Exemple de base ```python from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor model = DiffusionGemmaForBlockDiffusion.from_pretrained( "google/diffusiongemma-26B-A4B-it", device_map="auto", ) processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it") messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, {"type": "text", "text": "What is shown in this image?"}, ] }, ] inputs = processor.apply_chat_template( messages, tokenize=True, return_dict=True, return_tensors="pt", add_generation_prompt=True, # Add the following to enable thinking # enable_thinking=True, ).to(model.device) input_len = inputs["input_ids"].shape[-1] # Set `cache_implementation="static"` in `generate` to trigger `torch.compile`. # Compilation is much faster, after warming up! output = model.generate(**inputs, max_new_tokens=256) print(processor.decode(output.sequences[0][input_len:], skip_special_tokens=True)) ``` ### Streaming Comme d'autres modèles capables de générer du texte, vous pouvez définir une classe de streamer pour diffuser le texte en continu. Contrairement aux autres modèles, DiffusionGemma génère des brouillons intermédiaires avant le texte final. Vous pouvez les visualiser avec `TextDiffusionStreamer` ```python from transformers import TextDiffusionStreamer # (... copy from the example above, up to the `generate` call) streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer) model.generate(**inputs, max_new_tokens=256, streamer=streamer) ``` ### Définir une sortie de débruitage initiale Le modèle est entraîné à affiner itérativement des blocs de 256 jetons. Dans certaines applications, il peut être avantageux de fournir un point de départ au décodeur, plutôt que de partir de jetons aléatoires. Vous pouvez utiliser `decoder_input_ids`, disponible sur toutes les interfaces de modèle, pour définir le canevas de départ. ```py initial_estimate = ... # a tensor with shape (bsz, 256) model.generate(**inputs, max_new_tokens=256, decoder_input_ids=initial_estimate) ``` ## DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]] #### transformers.DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]] ```python transformers.DiffusionGemmaTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 262144, hidden_size: int = 2304, intermediate_size: int = 9216, num_hidden_layers: int = 30, num_attention_heads: int = 8, num_key_value_heads: int = 4, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, tie_word_embeddings: bool = True, rope_parameters: dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int = 512, layer_types: list[str] | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = None, num_experts: int | None = None, top_k_experts: int | None = None, moe_intermediate_size: int | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L35) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `262144`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, valeur par défaut `2304`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `9216`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `30`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_key_value_heads (`int`, *facultatif*, valeur par défaut `4`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est l'attention GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant la moyenne (meanpooling) de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`. head_dim (`int`, *facultatif*, valeur par défaut `256`) : La dimension des têtes d'attention. Si None, elle prendra par défaut la valeur hidden_size // num_attention_heads hidden_activation (`str`, *facultatif*, par défaut `gelu_pytorch_tanh`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *facultatif*, valeur par défaut `131072`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms. pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `1`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. rope_parameters (`dict`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention. attention_dropout (`Union[int, float]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. sliding_window (`int`, *facultatif*, valeur par défaut `512`) : Taille de la fenêtre pour l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée. layer_types (`list[str]`, *facultatif*) : Une liste qui associe explicitement chaque index de couche à son type de couche. S'il n'est pas fourni, il sera généré automatiquement en fonction des valeurs de configuration. use_bidirectional_attention (`str`, *facultatif*) : Contrôle le comportement de l'attention bidirectionnelle. Lorsqu'il est défini sur `"vision"`, les jetons visuels utilisent une attention bidirectionnelle tandis que les jetons de texte utilisent une attention causale. Lorsqu'il est défini sur `"all"`, tous les jetons utilisent une attention bidirectionnelle. num_experts (`int`, *facultatif*) : Nombre d'experts routés dans les couches MoE. top_k_experts (`int`, *facultatif*) : Nombre d'experts activés par jeton dans les couches MoE. moe_intermediate_size (`int`, *facultatif*) : Taille intermédiaire (cachée) du réseau feed-forward de chaque expert dans les couches MoE. Il s'agit de la classe de configuration destinée à stocker la configuration d'un DiffusionGemmaModel. Elle est utilisée pour instancier un modèle Diffusion Gemma en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]] #### transformers.DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]] ```python transformers.DiffusionGemmaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True, canvas_length: int | None = 256) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L162) **Paramètres :** text_config (`Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel. boi_token_id (`int`, *facultatif*, valeur par défaut 255999) : L'index du jeton de début d'image à utiliser pour encadrer le prompt d'image. eoi_token_id (`int`, *facultatif*, valeur par défaut 258882) : L'index du jeton de fin d'image utilisé pour encadrer le prompt d'image. image_token_id (`int`, *facultatif*, valeur par défaut `258880`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. canvas_length (`int`, *facultatif*, valeur par défaut 256) : La taille de la toile ou, autrement dit, la longueur du bloc dans la diffusion par blocs. Utilisé pour initialiser une toile vide. Il s'agit de la classe de configuration destinée à stocker la configuration d'un DiffusionGemmaModel. Elle est utilisée pour instancier un modèle Diffusion Gemma en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import ( >>> DiffusionGemmaConfig, >>> DiffusionGemmaModel, >>> DiffusionGemmaTextConfig, >>> Gemma4VisionConfig, >>> ) >>> # Initializing a DiffusionGemma Text config. >>> text_config = DiffusionGemmaTextConfig() >>> # Initializing a Gemma 4 vision config (DiffusionGemma uses Gemma 4's vision block). >>> vision_config = Gemma4VisionConfig() >>> # Initializing a DiffusionGemma text config >>> configuration = DiffusionGemmaConfig(text_config, vision_config) >>> # Initializing a model from the configuration >>> model = DiffusionGemmaModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]] #### transformers.DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]] ```python transformers.DiffusionGemmaGenerationOutput(sequences: LongTensor, tokens_per_forward: int | None = None, past_key_values: transformers.cache_utils.Cache | None = None, logits: None = None, scores: None = None, hidden_states: None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L247) **Paramètres :** sequences (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Les séquences générées, y compris le prompt si `input_ids` a été fourni à la méthode `generate`. tokens_per_forward (`torch.LongTensor` de forme (`batch_size`)) : Le nombre de jetons par passe avant dans cet appel `generate`, pour chaque membre du lot. Cette valeur est souvent utilisée comme métrique d'évaluation secondaire pour les modèles de diffusion de texte. past_key_values (`Cache`) : le cache utilisé pour la génération. Il peut être transmis aux appels suivants de `generate` pour accélérer la génération, dans le cadre de sessions multi-tours. logits (`None`) : Non utilisé. Conservé dans l'interface pour la rétrocompatibilité. scores (`None`) : Non utilisé. Conservé dans l'interface pour la rétrocompatibilité. hidden_states (`None`) : Non utilisé. Conservé dans l'interface pour la rétrocompatibilité. Classe de sortie pour la génération de DiffusionGemma. ## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]] #### transformers.DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]] ```python transformers.DiffusionGemmaGenerationMixin() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L543) Classe de mixin pour la génération de DiffusionGemma. Contient toutes les méthodes au niveau du modèle. #### generate[[transformers.DiffusionGemmaGenerationMixin.generate]] ```python generate(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, streamer: transformers.generation.streamers.BaseStreamer | None = None, generation_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L548) **Paramètres :** input_ids (*torch.LongTensor* de forme *(batch_size, sequence_length)*, *facultatif*) : La séquence utilisée comme invite pour la génération. past_key_values ([Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache), *facultatif*) : Objet de type Cache contenant les valeurs de clé passées et les masques d'attention passés pour le décodeur. S'il est défini, `input_ids` et/ou `pixel_values` doivent correspondre uniquement aux données non mises en cache. streamer (`BaseStreamer`, *facultatif*) : Objet Streamer utilisé pour diffuser les séquences générées. Les jetons générés sont transmis via `streamer.put(token_ids)` et le streamer est responsable de tout traitement ultérieur. Si l'objet streamer possède une méthode `put_draft`, les jetons issus des étapes de débruitage y seront envoyés. **Arguments supplémentaires pour les utilisateurs avancés :** generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération, en remplaçant les valeurs par défaut du modèle. Si le point de contrôle du modèle contient un fichier `generation_config.json`, les valeurs par défaut du modèle seront chargées depuis ce fichier. Sinon, il s'agira d'une instance vide de `DiffusionGemmaGenerationConfig`. En tant que raccourci supplémentaire, les `**kwargs` correspondant aux attributs de `generation_config` les remplaceront. logits_processor ([LogitsProcessorList](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.LogitsProcessorList), *facultatif*) : Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut construits à partir des arguments et de la configuration de génération, à appliquer sur les logits de diffusion. S'ils sont fournis, ces processeurs seront appliqués en premier. Cette fonctionnalité est destinée aux utilisateurs avancés. Vous pouvez, par exemple, y passer les processeurs de logits couramment utilisés avec les LLM AR. stopping_criteria ([StoppingCriteriaList](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.StoppingCriteriaList), *optionnel*) : Critères d'arrêt personnalisés qui complètent les critères d'arrêt autorégressifs par défaut du bloc, construits à partir des arguments et d'une configuration de génération. S'ils sont fournis, ces critères seront appliqués en premier. Cette fonctionnalité est destinée aux utilisateurs avancés. Vous pouvez, par exemple, y transmettre les critères d'arrêt couramment utilisés avec les LLM autorégressifs. kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc de `generation_config` et/ou d'autres arguments spécifiques au modèle qui seront transmis à la fonction `forward` du modèle. Par exemple, vous pouvez définir le canevas de départ avec `decoder_input_ids`. **Retourne :** `torch.LongTensor` ou [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput) - `torch.LongTensor` : le texte généré en identifiants. - [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput) : une instance de `ModelOutput` contenant le texte généré (`sequences`), ainsi que d'autres sorties facultatives. Génère du texte à l'aide du modèle de diffusion. Il contient une boucle externe effectuant la génération autorégressive de canevas (blocs de jetons) et une boucle boucle effectuant la diffusion sur chaque canevas. L'algorithme fonctionne approximativement comme suit : ``` 1. Autoregressive canvas generation loop: a. Encode all previous tokens using the encoder, to get the KV cache. b. Prepare data for the new denoising loop c. For each denoising (diffusion) step: i. Run the decoder, taking the current canvas, the encoder KV cache, and the self-conditioning logits (if available) as inputs. ii. Select new canvas tokens from the output logits. iii. Apply the sampler acceptance and renoising logic. iv. Update the diffusion stopping criteria. v. Use the output logits as self-conditioning logits for the next step. d. Append the new denoised canvas to the sequence of generated tokens. e. Check if any autoregressive stopping criteria are met, and break the outer loop if all sequences have met them. Replaces generated tokens in finished sequences by pad. f. Prepare tensors for the next block ``` Exemples : ```python >>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer >>> model = DiffusionGemmaForBlockDiffusion.from_pretrained( ... "google/diffusiongemma-26B-A4B-it", device_map="auto", >>> ) >>> chat = [{"role": "user", "content": "Why is the sky blue?"},] >>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it") >>> input_ids = processor.apply_chat_template(chat, tokenize=True, return_tensors="pt") >>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer) >>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer) ``` ## DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]] #### transformers.DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]] ```python transformers.DiffusionGemmaGenerationConfig(**kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L55) **Paramètres qui contrôlent la longueur de la sortie :** max_new_tokens (`int`, *facultatif*) : Le nombre maximal de jetons à générer, en ignorant le nombre de jetons du prompt. max_length (`int`, *facultatif*) : La longueur maximale de la séquence de sortie. `max_new_tokens` est recommandé pour contrôler le nombre de jetons générés par le modèle. **Paramètres de diffusion :** max_denoising_steps (`int`) : Nombre maximal d'étapes de débruitage à effectuer. sampler_config (`EntropyBoundSamplerConfig`) : La configuration du sampler. Consultez [EntropyBoundSampler](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.EntropyBoundSampler) pour comprendre le fonctionnement d'un sampler dans un modèle de diffusion de texte. t_min (`float`) : Température finale du planning, c'est-à-dire à la dernière étape de débruitage. Voir [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) pour plus de détails. t_max (`float`) : Température initiale du planning, c'est-à-dire à la première étape de débruitage. Voir [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) pour plus de détails. stability_threshold (`int`) : Nombre d'étapes pendant lesquelles le canevas accepté doit être identique pour déclencher les critères d'arrêt. Voir [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) pour plus de détails. confidence_threshold (`float`) : Seuil pour la moyenne de l'entropie des logits mis à l'échelle de la température afin de déclencher les critères d'arrêt. Voir [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) pour plus de détails. **Paramètres qui contrôlent le cache :** cache_implementation (`str`, *facultatif*) : Nom de la classe de cache qui sera instanciée dans `generate`, pour un décodage plus rapide. Les valeurs possibles sont : - `"dynamic"` : [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) - `"static"` : [StaticCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.StaticCache) - `"offloaded"` : `DynamicCache(offloaded=True)` - `"offloaded_static"` : `StaticCache(offloaded=True)` - `"quantized"` : [QuantizedCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.QuantizedCache) Si aucune valeur n'est spécifiée, le cache par défaut du modèle sera utilisé (souvent [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache)). Consultez notre [documentation sur le cache](https://huggingface.co/docs/transformers/en/kv_cache) pour plus d'informations. cache_config (`dict`, *facultatif*, par défaut `None`) : Les arguments utilisés dans la classe de cache clé-valeur peuvent être passés dans `cache_config`. **Jetons spéciaux qui peuvent être utilisés lors de la génération :** bos_token_id (`int`, *facultatif*) : L'identifiant du jeton *beginning-of-sequence*. pad_token_id (`int`, *facultatif*) : L'identifiant du jeton de *padding*. eos_token_id (`Union[int, list[int]]`, *facultatif*) : L'identifiant du jeton *end-of-sequence*. Facultativement, utilisez une liste pour définir plusieurs jetons *end-of-sequence*. Une classe GenerationConfig avec une paramétrisation personnalisée pour [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). ## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]] #### transformers.EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]] ```python transformers.EntropyBoundSamplerConfig(entropy_bound: float) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L320) **Paramètres :** entropy_bound (`float`) : La borne d'entropie. Plus cette valeur est élevée, plus de jetons seront acceptés. Consultez la docstring de [EntropyBoundSampler.accept_canvas()](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas) pour plus de détails sur son application. Classe de configuration pour l'échantillonneur à borne d'entropie. ## EntropyBoundSampler[[transformers.EntropyBoundSampler]] #### transformers.EntropyBoundSampler[[transformers.EntropyBoundSampler]] ```python transformers.EntropyBoundSampler(config: EntropyBoundSamplerConfig, canvas_length: int, vocab_size: int, max_denoising_steps: int) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L343) **Paramètres :** config (`EntropyBoundSamplerConfig`) : La configuration du sampler. canvas_length (`int`) : La longueur du canevas. vocab_size (`int`) : La taille du vocabulaire. max_denoising_steps (`int`) : Nombre maximal d'étapes de débruitage. (Non utilisé dans ce sampleur) Classe de sampler qui initialise un canevas avec des jetons aléatoires, accepte les jetons en fonction de l'entropie au niveau des jetons et rebruit les jetons non acceptés. Voici un schéma général du fonctionnement de la boucle de l'échantillonneur : ``` +-----------------------+ | Canvas initialization | | x_T ∈ U(V) | +-----------+-----------+ | v +----------+---------+ +---------------------+ +--------->| Current canvas x_t |------>| Denoiser canvas x_D | | +----------+---------+ +----------+----------+ | \ / | \ / | \ Acceptance logic / | v v | +-------------------------+ | Stop if max | Accepted canvas x_{t-1} | | denosing steps +------------+------------+ +-------------------+ | reached or \ | New canvas ∈ U(V) | | adaptive stopping \ +---------+---------+ | triggers \ Renoising logic / | v v | +-------------------------+ +---------------------------------------| Next canvas x_{t-1} | +-------------------------+ ``` #### accept_canvas[[transformers.EntropyBoundSampler.accept_canvas]] ```python accept_canvas(current_canvas: LongTensor, denoiser_canvas: LongTensor, logits: Tensor, cur_step: int) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L406) **Paramètres :** current_canvas (`torch.LongTensor`) : Le canevas actuel. denoiser_canvas (`torch.LongTensor`) : Le canevas échantillonné à partir des prédictions du débruiteur. logits (`torch.Tensor`) : Les logits issus du débruiteur. cur_step (`int`) : L'étape actuelle. **Retourne :** `torch.LongTensor` Le canevas accepté. Accepte les jetons issus du débruiteur en fonction d'une borne d'entropie. Plus concrètement, l'échantillonnage consiste à accepter les k jetons ayant l'entropie la plus faible, de sorte que sum_i^k entropy_i - max(entropy_1, ..., entropy_k) <= entropy_bound, où le membre de gauche est la borne supérieure de l'information mutuelle conjointe entre ces jetons, et le sampleur choisit donc k jetons qui sont approximativement indépendants. Proposé à l'origine dans https://arxiv.org/pdf/2505.24857 #### initialize_canvas[[transformers.EntropyBoundSampler.initialize_canvas]] ```python initialize_canvas(batch_size: int, device: device) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L394) Initialise et renvoie un nouveau canevas de `canvas_length` jetons avec des valeurs aléatoires issues du vocabulaire. #### renoise_canvas[[transformers.EntropyBoundSampler.renoise_canvas]] ```python renoise_canvas(accepted_canvas: LongTensor, cur_step: int) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L450) **Paramètres :** accepted_canvas (`torch.LongTensor`) : Le canevas accepté. cur_step (`int`) : L'étape actuelle. (Non utilisé dans ce sampleur) **Retourne :** `torch.LongTensor` La toile rebruitée. Rééchantillonne tous les jetons non acceptés. ## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]] #### transformers.StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]] ```python transformers.StableAndConfidentStoppingCriteria(stability_threshold: int, confidence_threshold: float) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L484) **Paramètres :** stability_threshold (`int`) : Nombre d'étapes pendant lesquelles le canevas accepté doit être identique pour déclencher les critères d'arrêt. confidence_threshold (`float`) : Seuil de la moyenne de l'entropie des logits mis à l'échelle de la température pour déclencher les critères d'arrêt. Stratégie d'arrêt adaptatif qui s'arrête lorsque le processus de diffusion est confiant et stable. Plus précisément : - Le processus de diffusion est stable lorsque les toiles acceptées sont identiques sur `stability_threshold` étapes. - Le processus de diffusion est considéré comme fiable lorsque la moyenne de l'entropie des logits traités est inférieure à `confidence_threshold`. ## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]] #### transformers.LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]] ```python transformers.LinearTemperatureScheduleLogitsProcessor(t_min: float, t_max: float, max_denoising_steps: int) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L276) **Paramètres :** t_min (`float`) : Température finale du planning, c'est-à-dire à la dernière étape de débruitage. t_max (`float`) : Température initiale du planning, c'est-à-dire à la première étape de débruitage. max_denoising_steps (`int`) : Nombre maximal d'étapes de débruitage. Processeur de logits qui applique un plan de température linéaire aux logits. Cela est similaire à `TemperatureLogitsWarper`, à l'exception près que la température est une fonction de l'étape actuelle. À l'étape n sur N, la température t est donnée par t = t_min + ((t_max - t_min) * (n/N)). ## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]] #### transformers.DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]] ```python transformers.DiffusionGemmaPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L817) **Paramètres :** config ([PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.DiffusionGemmaPreTrainedModel.forward]] ```python forward(*args, **kwargs) ``` Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice. ## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]] #### transformers.DiffusionGemmaModel[[transformers.DiffusionGemmaModel]] ```python transformers.DiffusionGemmaModel(config: DiffusionGemmaConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1452) **Paramètres :** config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Diffusion Gemma brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.DiffusionGemmaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1494) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Identifiants de jetons non mis en cache pour le prompt à encoder en tant que contexte pour le canevas. attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)` ou `dict`, *facultatif*) : Masque pour les jetons d'entrée. past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) decoder_input_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`, *facultatif*) : Identifiants des jetons pour le canevas à affiner. self_conditioning_logits (`torch.Tensor` de forme `(batch_size, canvas_length, vocab_size)`, *facultatif*) : Logits d'auto-conditionnement de l'étape de débruitage précédente, utilisés pour calculer les embeddings d'auto-conditionnement. self_conditioning_mask (`torch.BoolTensor` de forme `(batch_size,)`, *facultatif*) : masque par exemple sur `self_conditioning_logits` : les exemples définis sur `False` reçoivent un signal d'auto-conditionnement mis à zéro, comme si aucun logit n'avait été transmis pour eux. Utile pour l'entraînement, où l'auto-conditionnement est activé par exemple avec une certaine probabilité. decoder_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length+canvas_length)` ou `dict`, *facultatif*) : Masque d'attention pour le cache KV du décodeur. Utilisé pour spécifier les entrées du cache KV de l'encodeur remplies par des valeurs de bourrage ou non renseignées. decoder_position_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`, *facultatif*) : Les identifiants de position des jetons dans le canevas. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** `DiffusionGemmaModelOutputWithPast` ou `tuple(torch.Tensor)` Un `DiffusionGemmaModelOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) et les entrées. La méthode forward du modèle [DiffusionGemmaModel](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel) surcharge la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Défini uniquement lorsque `input_ids` est fourni, par exemple pour calculer une perte autorégressive sur l'encodeur pendant l'entraînement. ## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]] #### transformers.DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]] ```python transformers.DiffusionGemmaEncoderModel(config: DiffusionGemmaConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L995) **Paramètres :** config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle d'encodeur DiffusionGemma, composé d'un backbone visuel et d'un modèle de langage, *sans* tête de modélisation du langage. Il est très similaire à Gemma4Model, à l'exception du fait qu'il ne prend pas en charge les entrées audio ou vidéo et qu'il suppose toujours le chemin de code MoE dans les couches internes. Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.DiffusionGemmaEncoderModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, image_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1060) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails ([Gemma4Processor](/docs/transformers/v5.23.0/fr/model_doc/gemma4#transformers.Gemma4Processor) utilise `image_processor_class` pour le traitement des images). attention_mask (`Union[torch.Tensor, dict]` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. mm_token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée correspondant à chaque modalité. Par exemple, texte (0), image (1), vidéo (2). Les identifiants de type de jeton multimodal peuvent être obtenus à l'aide de [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor). Consultez [ProcessorMixin.__call__()](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. image_position_ids (`torch.LongTensor` de forme `(batch_size, max_patches, 2)`, *facultatif*) : coordonnées de position des patches 2D issues du processeur d’images, où `(-1, -1)` indique le bourrage. Transmise à l’encodeur visuel pour le calcul des embeddings positionnels. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) et les entrées. La méthode forward du [DiffusionGemmaEncoderModel](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]] #### transformers.DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]] ```python transformers.DiffusionGemmaEncoderTextModel(config: DiffusionGemmaTextConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L881) #### forward[[transformers.DiffusionGemmaEncoderTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L909) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`Union[torch.Tensor, dict]` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. **Retourne :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) et les entrées. La méthode forward du [DiffusionGemmaEncoderTextModel](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]] #### transformers.DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]] ```python transformers.DiffusionGemmaDecoderModel(config: DiffusionGemmaConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1175) Modèle décodeur pour DiffusionGemma. Traite les jetons du canevas avec une auto-attention bidirectionnelle et une attention croisée vers le cache KV de l'encodeur. Le décodeur lit le cache KV sans le mettre à jour. À ces différences près, il est similaire à `DiffusionGemmaEncoderTextModel`, et ils partagent tous les poids qu'ils ont en commun. #### forward[[transformers.DiffusionGemmaDecoderModel.forward]] ```python forward(decoder_input_ids: LongTensor, past_key_values: transformers.cache_utils.Cache | None = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1217) **Paramètres :** decoder_input_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`) : Identifiants des jetons pour le canevas à affiner. past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. self_conditioning_logits (`torch.Tensor` de forme `(batch_size, canvas_length, vocab_size)`, *facultatif*) : Logits d'auto-conditionnement de l'étape de débruitage précédente, utilisés pour calculer les embeddings d'auto-conditionnement. self_conditioning_mask (`torch.BoolTensor` de forme `(batch_size,)`, *facultatif*) : masque par exemple sur `self_conditioning_logits` : les exemples définis sur `False` reçoivent un signal d'auto-conditionnement mis à zéro, comme si aucun logit n'avait été transmis pour eux. Utile pour l'entraînement, où l'auto-conditionnement est activé par exemple avec une certaine probabilité. decoder_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length+canvas_length)` ou `dict`, *facultatif*) : Masque d'attention pour le cache KV du décodeur. Utilisé pour spécifier les entrées du cache KV de l'encodeur remplies par des valeurs de bourrage ou non renseignées. decoder_position_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`, *facultatif*) : Les identifiants de position des jetons dans le canevas. **Retourne :** [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Un [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) et les entrées. La méthode forward du [DiffusionGemmaDecoderModel](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]] #### transformers.DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]] ```python transformers.DiffusionGemmaForBlockDiffusion(config: DiffusionGemmaConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1579) Modèle DiffusionGemma pour la diffusion par blocs. Il appelle `DiffusionGemmaModel` afin d’obtenir les états cachés du canevas d’entrée, conditionnés par un cache KV de l’invite. À l’aide de sa tête LM et de ses blocs d’auto-conditionnement, il convertit ces états cachés en logits pour échantillonner le canevas suivant, ainsi que les embeddings d’auto-conditionnement pour l’étape suivante de la diffusion par blocs. #### forward[[transformers.DiffusionGemmaForBlockDiffusion.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1601) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Identifiants de jetons non mis en cache pour le prompt à encoder en tant que contexte pour le canevas. attention_mask (`torch.LongTensor` de forme `(batch_size, sequence_length)` ou `dict`, *facultatif*) : Masque pour les jetons d'entrée. past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) decoder_input_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`, *facultatif*) : Identifiants des jetons pour le canevas à affiner. self_conditioning_logits (`torch.Tensor` de forme `(batch_size, canvas_length, vocab_size)`, *facultatif*) : Logits d'auto-conditionnement de l'étape de débruitage précédente, utilisés pour calculer les embeddings d'auto-conditionnement. self_conditioning_mask (`torch.BoolTensor` de forme `(batch_size,)`, *facultatif*) : masque par exemple sur `self_conditioning_logits` : les exemples définis sur `False` reçoivent un signal d'auto-conditionnement mis à zéro, comme si aucun logit n'avait été transmis pour eux. Utile pour l'entraînement, où l'auto-conditionnement est activé par exemple avec une certaine probabilité. decoder_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length+canvas_length)` ou `dict`, *facultatif*) : Masque d'attention pour le cache KV du décodeur. Utilisé pour spécifier les entrées du cache KV de l'encodeur remplies par des valeurs de bourrage ou non renseignées. decoder_position_ids (`torch.LongTensor` de forme `(batch_size, canvas_length)`, *facultatif*) : Les identifiants de position des jetons dans le canevas. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** `DiffusionGemmaBlockDiffusionOutputWithPast` ou `tuple(torch.Tensor)` Un `DiffusionGemmaBlockDiffusionOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) et les entrées. La méthode forward de [DiffusionGemmaForBlockDiffusion](/docs/transformers/v5.23.0/fr/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*) -- Perte de modélisation du langage. - **logits** (`torch.Tensor` de forme `(batch_size, canvas_length, config.text_config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Défini uniquement lorsque `input_ids` est fourni, par exemple pour calculer une perte autorégressive sur l'encodeur pendant l'entraînement. Exemple : ```python >>> from PIL import Image >>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion >>> model = DiffusionGemmaForBlockDiffusion.from_pretrained("google/diffusiongemma-26B-A4B-it") >>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ```