Transformers documentation
DiffusionGemma
Ce modèle a été contribué à Hugging Face Transformers le 2026-06-10.
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, traitant le prompt initial et 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, 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. Vous pouvez trouver un guide visuel du modèle ici.
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(). Si vous utilisez un autre modèle transformers dans votre application, vous devriez pouvoir le remplacer directement par ce modèle.
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 pour des exemples d’utilisation, et ouvrez un issue 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_kne 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
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
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.
initial_estimate = ... # a tensor with shape (bsz, 256)
model.generate(**inputs, max_new_tokens=256, decoder_input_ids=initial_estimate)DiffusionGemmaTextConfig
classe transformers.DiffusionGemmaTextConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 262144hidden_size: int = 2304intermediate_size: int = 9216num_hidden_layers: int = 30num_attention_heads: int = 8num_key_value_heads: int = 4head_dim: int = 256hidden_activation: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-06pad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1bos_token_id: int | None = 2tie_word_embeddings: bool = Truerope_parameters: dict | None = Noneattention_bias: bool = Falseattention_dropout: int | float | None = 0.0sliding_window: int = 512layer_types: list[str] | None = Noneuse_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = Nonenum_experts: int | None = Nonetop_k_experts: int | None = Nonemoe_intermediate_size: int | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut262144) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par lesinput_ids. - hidden_size (
int, facultatif, par défaut2304) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut9216) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut30) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif, valeur par défaut4) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut seranum_attention_heads. - head_dim (
int, facultatif, par défaut256) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - hidden_activation (
str, facultatif, par défautgelu_pytorch_tanh) — La 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, par défaut131072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - rms_norm_eps (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation rms. - pad_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut1) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut2) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - rope_parameters (
dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - attention_bias (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention. - attention_dropout (
Union[int, float], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - sliding_window (
int, facultatif, par défaut512) — Taille de la fenêtre d'attention glissante. SiNone, 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 de propagation avant de chaque expert dans les couches MoE.
Ceci est 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, définissant ainsi 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
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
DiffusionGemmaConfig
classe transformers.DiffusionGemmaConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = Nonevision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = Noneboi_token_id: int | None = 255999eoi_token_id: int | None = 258882image_token_id: int | None = 258880initializer_range: float | None = 0.02tie_word_embeddings: bool = Truecanvas_length: int | None = 256 )
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, par défaut 255999) — L'index du jeton de début d'image utilisé pour encadrer le prompt d'image. - eoi_token_id (
int, facultatif, valeur par défaut 258882) — L’indice du jeton de fin d’image utilisé pour encadrer le prompt d’image. - image_token_id (
int, facultatif, par défaut258880) — L’index du jeton d’image utilisé comme espace réservé pour les images d’entrée. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - canvas_length (
int, facultatif, par défaut 256) — La taille du canevas ou, autrement dit, la longueur du bloc dans la diffusion par bloc. Utilisé pour initialiser un canevas vide.
Ceci est 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, définissant ainsi 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
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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.configDiffusionGemmaGenerationOutput
classe transformers.DiffusionGemmaGenerationOutput
< source >( sequences: LongTensortokens_per_forward: int | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonelogits: None = Nonescores: None = Nonehidden_states: None = None )
Paramètres
- sequences (
torch.LongTensorde forme(batch_size, sequence_length)) — Les séquences générées, y compris le prompt siinput_idsa été fourni à la méthodegenerate. - tokens_per_forward (
torch.LongTensorde forme (batch_size)) — Le nombre de jetons par passe avant dans cet appelgenerate, pour chaque membre du lot. Cela est souvent utilisé 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 degeneratepour accélérer la génération, dans les 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
Classe de mixin pour la génération de DiffusionGemma. Contient toutes les méthodes au niveau du modèle.
generate
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonestreamer: transformers.generation.streamers.BaseStreamer | None = Nonegeneration_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None**kwargs ) → torch.LongTensor or DiffusionGemmaGenerationOutput
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, facultatif) —
Objet de cache contenant les valeurs de clés passées et les masques d'attention passés pour le décodeur. S'il est défini,
input_idset/oupixel_valuesdoivent correspondre uniquement aux données non mises en cache. - streamer (
BaseStreamer, facultatif) — Objet de diffusion utilisé pour diffuser les séquences générées. Les jetons générés sont transmis viastreamer.put(token_ids)et l'objet de diffusion est responsable de tout traitement ultérieur. Si l'objet de diffusion possède une méthodeput_draft, les jetons des étapes de débruitage y seront envoyés.
Arguments supplémentaires pour les utilisateurs avancés
- generation_config (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 deDiffusionGemmaGenerationConfig. En tant que raccourci supplémentaire, les**kwargscorrespondant aux attributs degeneration_configles remplaceront. - logits_processor (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, facultatif) — Critères d’arrêt personnalisés qui complètent les critères d’arrêt autorégressifs par bloc par défaut, 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 passer les critères d’arrêt couramment utilisés avec les LLM autorégressifs.
- kwargs (
dict[str, Any], facultatif) — Paramétrage ad hoc degeneration_configet/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonctionforwarddu modèle. Par exemple, vous pouvez définir le canevas de départ avecdecoder_input_ids.
Retourne
torch.LongTensor ou DiffusionGemmaGenerationOutput
torch.LongTensor: le texte généré en identifiants.- DiffusionGemmaGenerationOutput : une instance de
ModelOutputcontenant 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 blockExemples :
>>> 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
classe transformers.DiffusionGemmaGenerationConfig
< source >( **kwargs )
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_tokensest recommandé pour contrôler le nombre de jetons générés par le modèle.
Paramètres de diffusion
- max_denoising_steps (
int) — Le nombre maximal d'étapes de débruitage à effectuer. - sampler_config (
EntropyBoundSamplerConfig) — La configuration du sampler. Consultez EntropyBoundSampler pour comprendre le fonctionnement d'un sampler dans un modèle de diffusion de texte. - t_min (
float) — La température finale du planning, c’est-à-dire à la dernière étape de débruitage. Voir LinearTemperatureScheduleLogitsProcessor pour plus de détails. - t_max (
float) — La température initiale dans le planning, c’est-à-dire à la première étape de débruitage. Voir LinearTemperatureScheduleLogitsProcessor pour plus de détails. - stability_threshold (
int) — Le nombre d’étapes pendant lesquelles le canevas accepté doit rester identique pour déclencher les critères d’arrêt. Voir StableAndConfidentStoppingCriteria pour plus de détails. - confidence_threshold (
float) — Seuil appliqué à la moyenne de l’entropie des logits mis à l’échelle par la température pour déclencher les critères d’arrêt. Voir 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 dansgenerate, pour un décodage plus rapide. Les valeurs possibles sont :"dynamic": DynamicCache"static": StaticCache"offloaded":DynamicCache(offloaded=True)"offloaded_static":StaticCache(offloaded=True)"quantized": QuantizedCache
Si aucune n'est spécifiée, nous utiliserons le cache par défaut du modèle (souvent DynamicCache). Consultez notre documentation sur les caches pour plus d'informations.
- cache_config (
dict, facultatif, par défautNone) — Les arguments utilisés dans la classe de cache clé-valeur peuvent être passés danscache_config.
Jetons spéciaux qui peuvent être utilisés lors de la génération
- bos_token_id (
int, facultatif) — L’identifiant du jeton de début de séquence. - pad_token_id (
int, facultatif) — L'identifiant du jeton de remplissage. - 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().
EntropyBoundSamplerConfig
classe transformers.EntropyBoundSamplerConfig
< source >( entropy_bound: float )
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() pour plus de détails sur son application.
Classe de configuration pour l'échantillonneur à borne d'entropie.
EntropyBoundSampler
classe transformers.EntropyBoundSampler
< source >( config: EntropyBoundSamplerConfigcanvas_length: intvocab_size: intmax_denoising_steps: int )
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 rébruit 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
< source >( current_canvas: LongTensordenoiser_canvas: LongTensorlogits: Tensorcur_step: int ) → torch.LongTensor
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 du débruiteur en fonction d'une limite d'entropie. Plus concrètement, l'échantillonnage se déroule en acceptant 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
Initialise et renvoie un nouveau canevas de canvas_length jetons avec des valeurs aléatoires issues du vocabulaire.
renoise_canvas
< source >( accepted_canvas: LongTensorcur_step: int ) → torch.LongTensor
Rééchantillonne tous les jetons non acceptés.
StableAndConfidentStoppingCriteria
classe transformers.StableAndConfidentStoppingCriteria
< source >( stability_threshold: intconfidence_threshold: float )
Paramètres
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
classe transformers.LinearTemperatureScheduleLogitsProcessor
< source >( t_min: floatt_max: floatmax_denoising_steps: int )
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
classe transformers.DiffusionGemmaPreTrainedModel
< source >( config: PreTrainedConfig*inputs**kwargs )
Paramètres
- config (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() pour charger les poids du modèle.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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.
Valeur factice pour un chemin pointé (par exemple 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 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
classe transformers.DiffusionGemmaModel
< source >( config: DiffusionGemmaConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DiffusionGemmaModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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.Tensorde forme(batch_size, sequence_length)oudict, 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - position_ids (
torch.LongTensorde 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]. - decoder_input_ids (
torch.LongTensorde forme(batch_size, canvas_length), facultatif) — Identifiants des jetons pour le canevas à affiner. - self_conditioning_logits (
torch.Tensorde 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.BoolTensorde forme(batch_size,), facultatif) — Masque par exemple surself_conditioning_logits: les exemples définis surFalsereç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.Tensorde forme(batch_size, sequence_length+canvas_length)oudict, 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.LongTensorde 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions 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 en fonction de la configuration (DiffusionGemmaConfig) et des entrées.
La méthode forward du modèle 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
Moduleplutô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.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
encoder_last_hidden_state (
torch.Tensorde 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 lorsqueinput_idsest fourni, par exemple pour calculer une perte autorégressive sur l’encodeur pendant l’entraînement.
DiffusionGemmaEncoderModel
classe transformers.DiffusionGemmaEncoderModel
< source >( config: DiffusionGemmaConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonemm_token_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneimage_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide deimage_processor_class. Consultezimage_processor_class.__call__pour plus de détails (Gemma4Processor utiliseimage_processor_classpour 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 choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - mm_token_type_ids (
torch.LongTensorde 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. Consultez ProcessorMixin.call() pour plus de détails. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - image_position_ids (
torch.LongTensorde 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. Transmis à 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
BaseModelOutputWithPast ou tuple(torch.Tensor)
Un BaseModelOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DiffusionGemmaConfig) et des entrées.
La méthode forward du 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
Moduleplutô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.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
DiffusionGemmaEncoderTextModel
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- 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 choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle.
Retourne
BaseModelOutputWithPast ou tuple(torch.Tensor)
Un BaseModelOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DiffusionGemmaConfig) et des entrées.
La méthode forward du 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
Moduleplutô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.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
DiffusionGemmaDecoderModel
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. À l'exception de ces différences, il est similaire à DiffusionGemmaEncoderTextModel, et ils partagent tous les poids qu'ils ont en commun.
forward
< source >( decoder_input_ids: LongTensorpast_key_values: transformers.cache_utils.Cache | None = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)
Paramètres
- decoder_input_ids (
torch.LongTensorde 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - self_conditioning_logits (
torch.Tensorde 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.BoolTensorde forme(batch_size,), facultatif) — Masque par exemple surself_conditioning_logits: les exemples définis surFalsereç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.Tensorde forme(batch_size, sequence_length+canvas_length)oudict, 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.LongTensorde forme(batch_size, canvas_length), facultatif) — Les identifiants de position des jetons dans le canevas.
Retourne
BaseModelOutput ou tuple(torch.Tensor)
Un BaseModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DiffusionGemmaConfig) et des entrées.
La méthode forward du 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
Moduleplutô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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
DiffusionGemmaForBlockDiffusion
Modèle DiffusionGemma pour la diffusion par blocs. Il appelle DiffusionGemmaModel pour 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 afin d’échantillonner le canevas suivant, ainsi que les embeddings d’auto-conditionnement pour l’étape suivante de la diffusion par blocs.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DiffusionGemmaBlockDiffusionOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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.LongTensorde forme(batch_size, sequence_length)oudict, 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - position_ids (
torch.LongTensorde 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]. - decoder_input_ids (
torch.LongTensorde forme(batch_size, canvas_length), facultatif) — Identifiants des jetons pour le canevas à affiner. - self_conditioning_logits (
torch.Tensorde 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.BoolTensorde forme(batch_size,), facultatif) — Masque par exemple surself_conditioning_logits: les exemples définis surFalsereç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.Tensorde forme(batch_size, sequence_length+canvas_length)oudict, 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.LongTensorde 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions 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 en fonction de la configuration (DiffusionGemmaConfig) et des entrées.
La méthode forward de 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
Moduleplutô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.Tensorde forme(1,), facultatif) — Perte de modélisation du langage.logits (
torch.Tensorde 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
encoder_last_hidden_state (
torch.Tensorde 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 lorsqueinput_idsest fourni, par exemple pour calculer une perte autorégressive sur l’encodeur pendant l’entraînement.
Exemple :
>>> 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]