Hugging Face's logo

Transformers documentation

DiffusionGemma

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo fue aportado a Hugging Face Transformers el 2026-06-10.

DiffusionGemma

Resumen

DiffusionGemma está diseñado para reducir los cuellos de botella secuenciales de los modelos de lenguaje causales estándar. Emplea una arquitectura de codificador-decodificador optimizada específicamente para la velocidad de inferencia.

El codificador opera en una capacidad de prellenado, procesando el prompt inicial y generando la caché KV. A continuación, el decodificador utiliza la atención bidireccional para procesar un bloque de entrada (un ‘lienzo’) de tokens, accediendo al contexto en caché a través de la atención cruzada.

Durante la inferencia, DiffusionGemma aprovecha el muestreo multi-canvas. En lugar de generar un token a la vez, el modelo desruidifica iterativamente un bloque completo de tokens utilizando un muestreador de difusión. Una vez que un canvas está completamente desruidificado, se procesa con el codificador y se añade a la caché KV, tras lo cual el modelo genera el siguiente canvas. Este enfoque autoregresivo por bloques facilita la generación de texto a velocidades más altas.

Puedes encontrar la tarjeta del modelo y el punto de control aquí. Puedes encontrar una guía visual del modelo aquí.

Ejemplos de uso

Aunque se trata de un modelo de difusión de texto y tiene un bucle de generación personalizado, la mayor parte de la interfaz se comparte con otros modelos que pueden generar texto mediante DiffusionGemmaGenerationMixin.generate(). Si estás utilizando otro modelo de transformers en tu aplicación, deberías poder reemplazarlo directamente por este modelo.

DiffusionGemma está disponible tanto en Transformers como en Diffusers, pero Diffusers es su lugar principal. Diffusers cuenta con el conjunto completo de opciones de programación, utilidades de pipeline y nuevas funciones (programadores adicionales, criterios de parada, estrategias de muestreo) que solo se añaden allí. Consulta la DiffusionGemma para ver ejemplos de uso y abre un issue en Diffusers para experimentar con diferentes programadores o solicitar una función. La implementación en Transformers solo recibe correcciones de errores, pero no nuevas funciones.

Precauciones habituales

  • DiffusionGemma no acepta use_cache. Siempre utiliza una caché KV;
  • El soporte para banderas comunes como top_k no estará disponible el día del lanzamiento, pero se irá añadiendo con el tiempo si son compatibles con la difusión de texto.

Ejemplo básico

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

Al igual que otros modelos que pueden generar texto, puedes establecer una clase de streamer para transmitir el texto. A diferencia de otros modelos, DiffusionGemma genera borradores intermedios antes del texto final. Puedes visualizarlos con 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)

Establecer una salida inicial de eliminación de ruido

El modelo se entrena para refinar iterativamente bloques de 256 tokens. En algunas aplicaciones, puede ser beneficioso proporcionar un punto de partida para el decodificador, en lugar de comenzar con tokens aleatorios. Puede usar decoder_input_ids, disponible en todas las interfaces de modelo, para establecer el lienzo inicial.

initial_estimate = ... # a tensor with shape (bsz, 256)
model.generate(**inputs, max_new_tokens=256, decoder_input_ids=initial_estimate)

DiffusionGemmaTextConfig

clase transformers.DiffusionGemmaTextConfig

< >

( 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 )

Parámetros

  • vocab_size (int, opcional, valor predeterminado 262144) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • hidden_size (int, opcional, valor predeterminado 2304) — Dimensión de las representaciones ocultas.
  • intermediate_size (int, opcional, valor predeterminado 9216) — Dimensión de las representaciones del MLP.
  • num_hidden_layers (int, opcional, valor predeterminado 30) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • num_key_value_heads (int, opcional, valor predeterminado 4) — Este es el número de cabezas key_value que se deben utilizar para implementar Grouped Query Attention. Si num_key_value_heads=num_attention_heads, el modelo utilizará Multi Head Attention (MHA); si num_key_value_heads=1, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head en un checkpoint GQA, cada cabeza de clave y valor del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta este artículo. Si no se especifica, el valor predeterminado será num_attention_heads.
  • head_dim (int, opcional, valor predeterminado 256) — La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads
  • hidden_activation (str, opcional, valor predeterminado gelu_pytorch_tanh) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, valor predeterminado 131072) — La longitud máxima de secuencia con la que podría utilizarse este modelo.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • rms_norm_eps (float, opcional, valor predeterminado 1e-06) — El epsilon utilizado por las capas de normalización rms.
  • pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
  • eos_token_id (Union[int, list[int]], opcional, valor predeterminado 1) — Identificador de token utilizado para el fin de secuencia en el vocabulario.
  • bos_token_id (int, opcional, valor predeterminado 2) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.
  • rope_parameters (dict, opcional) — Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para rope_theta y, opcionalmente, los parámetros utilizados para el escalado en caso de que desee usar RoPE con max_position_embeddings más largos.
  • attention_bias (bool, opcional, valor predeterminado False) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.
  • attention_dropout (Union[int, float], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • sliding_window (int, opcional, valor predeterminado 512) — Tamaño de la ventana de atención deslizante. Si es None, no se aplica ninguna ventana deslizante.
  • layer_types (list[str], opcional) — Una lista que asigna explícitamente cada índice de capa con su tipo de capa. Si no se proporciona, se generará automáticamente en función de los valores de la configuración.
  • use_bidirectional_attention (str, opcional) — Controla el comportamiento de la atención bidireccional. Cuando se establece en "vision", los tokens de visión atienden bidireccionalmente, mientras que los tokens de texto usan atención causal. Cuando se establece en "all", todos los tokens usan atención bidireccional.
  • num_experts (int, opcional) — Número de expertos enrutados en las capas MoE.
  • top_k_experts (int, opcional) — Número de expertos activados por token en las capas MoE.
  • moe_intermediate_size (int, opcional) — Tamaño intermedio (oculto) de la red feed-forward de cada experto en las capas MoE.

Esta es la clase de configuración para almacenar la configuración de un DiffusionGemmaModel. Se utiliza para instanciar un modelo Diffusion Gemma según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de google/diffusiongemma-26B-A4B-it

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

DiffusionGemmaConfig

clase transformers.DiffusionGemmaConfig

< >

( 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 )

Parámetros

  • text_config (Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]], opcional) — El objeto de configuración o el diccionario del backbone de texto.
  • vision_config (Union[~configuration_utils.PreTrainedConfig, dict[str, Any]], opcional) — El objeto de configuración o el diccionario del backbone de visión.
  • boi_token_id (int, opcional, valor predeterminado 255999) — Índice del token de inicio de imagen para envolver el prompt de imagen.
  • eoi_token_id (int, opcional, valor predeterminado 258882) — El índice del token de fin de imagen para envolver el prompt de imagen.
  • image_token_id (int, opcional, valor predeterminado 258880) — El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.
  • canvas_length (int, opcional, valor predeterminado 256) — El tamaño del lienzo o, en otras palabras, la longitud del bloque en la difusión por bloques. Se utiliza para inicializar un lienzo vacío.

Esta es la clase de configuración para almacenar la configuración de un DiffusionGemmaModel. Se utiliza para instanciar un modelo Diffusion Gemma según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de google/diffusiongemma-26B-A4B-it

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.DiffusionGemmaGenerationOutput

< >

( sequences: LongTensortokens_per_forward: int | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonelogits: None = Nonescores: None = Nonehidden_states: None = None )

Parámetros

  • sequences (torch.LongTensor de forma (batch_size, sequence_length)) — Las secuencias generadas, incluyendo el prompt si se proporcionó input_ids al método generate.
  • tokens_per_forward (torch.LongTensor de forma (batch_size)) — El número de tokens por forward en esta llamada a generate, para cada miembro del batch. Esto se utiliza a menudo como métrica de evaluación secundaria para modelos de difusión de texto.
  • past_key_values (Cache) — La caché utilizada para la generación. Puede pasarse a llamadas posteriores a generate para acelerar la generación en sesiones de varios turnos.
  • logits (None) — No se utiliza. Se mantiene en la interfaz por compatibilidad hacia atrás.
  • scores (None) — No se utiliza. Se mantiene en la interfaz por compatibilidad hacia atrás.
  • hidden_states (None) — No se utiliza. Se mantiene en la interfaz por compatibilidad hacia atrás.

Clase de salida para la generación de DiffusionGemma.

DiffusionGemmaGenerationMixin

clase transformers.DiffusionGemmaGenerationMixin

< >

( )

Clase mixin para la generación de DiffusionGemma. Contiene todos los métodos a nivel de modelo.

generate

< >

( 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

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — La secuencia utilizada como indicación para la generación.
  • past_key_values (Cache, opcional) — Objeto de caché que contiene los valores clave pasados y las máscaras de atención pasadas para el decodificador. Si se establece, input_ids y/o pixel_values deben corresponder únicamente a datos no almacenados en caché.
  • streamer (BaseStreamer, opcional) — Objeto que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de streamer.put(token_ids) y el streamer es responsable de cualquier procesamiento adicional. Si el objeto streamer tiene un método put_draft, los tokens de los pasos de denoising se enviarán allí.

Argumentos adicionales para usuarios avanzados

  • generation_config (DiffusionGemmaGenerationConfig, opcional) — La configuración de generación que se utilizará como parametrización base para la llamada de generación, reemplazando los valores predeterminados del modelo. Si el punto de control del modelo tiene un archivo generation_config.json, los valores predeterminados del modelo se cargarán desde allí. De lo contrario, será una instancia vacía de DiffusionGemmaGenerationConfig. Como atajo adicional, los **kwargs que coincidan con atributos en generation_config los reemplazarán.
  • logits_processor (LogitsProcessorList, opcional) — Procesadores de logits personalizados que complementan los procesadores de logits predeterminados construidos a partir de los argumentos y la configuración de generación, para aplicarse a los logits de difusión. Si se proporcionan, estos procesadores serán los primeros en aplicarse. Esta función está destinada a usuarios avanzados. Por ejemplo, puede pasar aquí los procesadores de logits comúnmente utilizados con LLMs AR.
  • stopping_criteria (StoppingCriteriaList, opcional) — Criterios de parada personalizados que complementan los criterios de parada autoregresivos de bloque predeterminados, construidos a partir de los argumentos y una configuración de generación. Si se proporcionan, estos criterios se aplicarán primero. Esta función está destinada a usuarios avanzados. Por ejemplo, puede pasar aquí los criterios de parada comúnmente utilizados con LLMs autoregresivos.
  • kwargs (dict[str, Any], opcional) — Parametrización ad hoc de generation_config y/o kwargs adicionales específicos del modelo que se reenviarán a la función forward del modelo. Por ejemplo, puedes establecer el lienzo inicial con decoder_input_ids.

Devuelve

torch.LongTensor o DiffusionGemmaGenerationOutput

  • torch.LongTensor: el texto generado en ids.
  • DiffusionGemmaGenerationOutput: una instancia de ModelOutput que contiene el texto generado (sequences), así como otras salidas opcionales.

Genera texto usando el modelo de difusión.

Contiene un bucle externo que realiza la generación autoregresiva de lienzos (bloques de tokens) y un bucle

bucle que realiza difusión en cada lienzo. El algoritmo funciona aproximadamente de la siguiente manera:

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

Ejemplos:

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

clase transformers.DiffusionGemmaGenerationConfig

< >

( **kwargs )

Parámetros que controlan la longitud de la salida

  • max_new_tokens (int, opcional) — El número máximo de tokens a generar, ignorando el número de tokens del prompt.
  • max_length (int, opcional) — La longitud máxima de la secuencia de salida. Se recomienda max_new_tokens para controlar cuántos tokens genera el modelo.

Parámetros de difusión

  • max_denoising_steps (int) — El número máximo de pasos de desruido a realizar.
  • sampler_config (EntropyBoundSamplerConfig) — La configuración del sampler. Consulte EntropyBoundSampler para aprender cómo funciona un sampler en un modelo de difusión de texto.
  • t_min (float) — La temperatura final en el programa, es decir, en el último paso de desruido. Consulte LinearTemperatureScheduleLogitsProcessor para más detalles.
  • t_max (float) — La temperatura inicial en la programación, es decir, en el primer paso de desruido. Consulte LinearTemperatureScheduleLogitsProcessor para más detalles.
  • stability_threshold (int) — El número de pasos durante los cuales el lienzo aceptado debe ser el mismo para activar los criterios de parada. Consulte StableAndConfidentStoppingCriteria para más detalles.
  • confidence_threshold (float) — Umbral para la media de la entropía de los logits escalados por temperatura que activa los criterios de parada. Consulte StableAndConfidentStoppingCriteria para más detalles.

Parámetros que controlan la caché

  • cache_implementation (str, opcional) — Nombre de la clase de caché que se instanciará en generate, para un decodificado más rápido. Los valores posibles son:

    Si no se especifica ninguna, se utilizará la caché predeterminada del modelo (que a menudo es DynamicCache). Consulte nuestra documentación de caché para obtener más información.

  • cache_config (dict, opcional, valor predeterminado None) — Los argumentos utilizados en la clase de caché de clave-valor pueden pasarse en cache_config.

Tokens especiales que se pueden usar en el momento de la generación

  • bos_token_id (int, opcional) — El id del token de inicio de secuencia.
  • pad_token_id (int, opcional) — El id del token de padding.
  • eos_token_id (Union[int, list[int]], opcional) — El id del token de fin de secuencia. Opcionalmente, use una lista para establecer varios tokens de fin de secuencia.

Una clase GenerationConfig con parametrización personalizada para DiffusionGemmaGenerationMixin.generate().

EntropyBoundSamplerConfig

clase transformers.EntropyBoundSamplerConfig

< >

( entropy_bound: float )

Parámetros

  • entropy_bound (float) — El límite de entropía. Cuanto mayor sea este valor, más tokens se aceptarán. Consulte la docstring de EntropyBoundSampler.accept_canvas() para obtener más detalles sobre cómo se aplica.

Clase de configuración para el muestreador de límite de entropía.

EntropyBoundSampler

clase transformers.EntropyBoundSampler

< >

( config: EntropyBoundSamplerConfigcanvas_length: intvocab_size: intmax_denoising_steps: int )

Parámetros

  • config (EntropyBoundSamplerConfig) — La configuración del muestreador.
  • canvas_length (int) — La longitud del lienzo.
  • vocab_size (int) — El tamaño del vocabulario.
  • max_denoising_steps (int) — El número máximo de pasos de desruido. (No se utiliza en este muestreador)

Clase de muestreador que inicializa un lienzo con tokens aleatorios, acepta tokens según la entropia a nivel de token y re-rumbea los tokens no aceptados.

Aquí hay un esquema general de cómo funciona el bucle del muestreador:

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

< >

( current_canvas: LongTensordenoiser_canvas: LongTensorlogits: FloatTensorcur_step: int ) → torch.LongTensor

Parámetros

  • current_canvas (torch.LongTensor) — El lienzo actual.
  • denoiser_canvas (torch.LongTensor) — El lienzo muestreado a partir de las predicciones del denoiser.
  • logits (torch.FloatTensor) — Los logits del desruidor.
  • cur_step (int) — El paso actual.

Devuelve

torch.LongTensor

El lienzo aceptado.

Acepta tokens del denoiser basándose en un límite de entropía. Más concretamente, el muestreo se realiza aceptando k tokens con la menor entropía, de modo que

sum_i^k entropy_i - max(entropy_1, …, entropy_k) <= entropy_bound,

donde el lado izquierdo es el límite superior de la información mutua conjunta entre estos tokens, y por lo tanto el muestreador elige k tokens que son aproximadamente independientes.

Propuesto originalmente en https://arxiv.org/pdf/2505.24857

initialize_canvas

< >

( batch_size: intdevice: device )

Inicializa y devuelve un nuevo lienzo de canvas_length tokens con valores aleatorios del vocabulario.

renoise_canvas

< >

( accepted_canvas: LongTensorcur_step: int ) → torch.LongTensor

Parámetros

  • accepted_canvas (torch.LongTensor) — El lienzo aceptado.
  • cur_step (int) — El paso actual. (No se usa en este muestreador)

Devuelve

torch.LongTensor

El lienzo re-ruido.

Renoisea todos los tokens no aceptados.

StableAndConfidentStoppingCriteria

clase transformers.StableAndConfidentStoppingCriteria

< >

( stability_threshold: intconfidence_threshold: float )

Parámetros

  • stability_threshold (int) — El número de pasos durante los cuales el lienzo aceptado debe ser el mismo para activar los criterios de parada.
  • confidence_threshold (float) — Umbral para la media de la entropía de los logits escalados por temperatura que activa los criterios de parada.

Estrategia de parada adaptativa que detiene el proceso cuando la difusión es confiable y estable. Para ser más específicos:

  • El proceso de difusión es estable cuando el lienzo aceptado es el mismo durante stability_threshold pasos.
  • El proceso de difusión es confiable cuando la media de la entropía de los logits procesados está por debajo de confidence_threshold.

LinearTemperatureScheduleLogitsProcessor

clase transformers.LinearTemperatureScheduleLogitsProcessor

< >

( t_min: floatt_max: floatmax_denoising_steps: int )

Parámetros

  • t_min (float) — La temperatura final en el programa, es decir, en el último paso de desruido.
  • t_max (float) — La temperatura inicial en el programa, es decir, en el primer paso de desruido.
  • max_denoising_steps (int) — El número máximo de pasos de desruido.

Procesador de logits que aplica un programa lineal de temperatura a los logits. Es similar a TemperatureLogitsWarper, con la excepción de que la temperatura es una función del paso actual.

En el paso n de N, la temperatura t se calcula como t = t_min + ((t_max - t_min) * (n/N)).

DiffusionGemmaPreTrainedModel

clase transformers.DiffusionGemmaPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parámetros

  • config (PreTrainedConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

( *args**kwargs )

Un valor simulado para una ruta con puntos (p. ej. torch.float32): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, repr es la ruta con puntos, y su uso como clase base sustituye una base de type simple (PEP 560 __mro_entries__), de modo que las subclases reales conservan un metaclass normal y inspect.signature lee su __init__ real en lugar del de un simulado.

DiffusionGemmaModel

clase transformers.DiffusionGemmaModel

< >

( config: DiffusionGemmaConfig )

Parámetros

  • config (DiffusionGemmaConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo Diffusion Gemma básico que genera estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( 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.FloatTensor] = 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.FloatTensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — IDs de tokens no cacheados para el prompt que se codificará como contexto para el lienzo.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length) o dict, opcional) — Máscara para los tokens de entrada.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, canvas_length), opcional) — IDs de tokens para el lienzo que se va a refinar.
  • self_conditioning_logits (torch.FloatTensor de forma (batch_size, canvas_length, vocab_size), opcional) — Logits de autocondicionamiento del paso de desruido anterior, utilizados para calcular los embeddings de autocondicionamiento.
  • self_conditioning_mask (torch.BoolTensor de forma (batch_size,), opcional) — Máscara por ejemplo sobre self_conditioning_logits: los ejemplos fijados en False reciben una señal de autocondicionamiento a cero, como si no se hubieran pasado logits para ellos. Útil para el entrenamiento, donde el autocondicionamiento se habilita por ejemplo con cierta probabilidad.
  • decoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length+canvas_length) o dict, opcional) — Máscara de atención para la caché KV del decodificador. Se utiliza para especificar las entradas de la caché KV del codificador rellenas o sin poblar.
  • decoder_position_ids (torch.LongTensor de forma (batch_size, canvas_length), opcional) — Los IDs de posición para los tokens en el lienzo.
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

Devuelve

DiffusionGemmaModelOutputWithPast o tuple(torch.FloatTensor)

Un DiffusionGemmaModelOutputWithPast o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DiffusionGemmaConfig) y las entradas.

El método forward de DiffusionGemmaModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • encoder_last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Solo se establece cuando se proporciona input_ids, por ejemplo, para calcular una pérdida autorregresiva en el codificador durante el entrenamiento.

DiffusionGemmaEncoderModel

clase transformers.DiffusionGemmaEncoderModel

< >

( config: DiffusionGemmaConfig )

Parámetros

  • config (DiffusionGemmaConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

El modelo de codificador DiffusionGemma, que comprende un backbone de visión y un modelo de lenguaje, sin una cabeza de modelado de lenguaje. Es muy similar a Gemma4Model, excepto que no admite entradas de audio o vídeo y siempre asume la ruta de código MoE en las capas internas.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = 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.FloatTensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • pixel_values (torch.FloatTensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando image_processor_class. Consulte image_processor_class.__call__ para más detalles (Gemma4Processor utiliza image_processor_class para procesar las imágenes).
  • attention_mask (Union[torch.Tensor, dict] de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • mm_token_type_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada que corresponden a cada modalidad. Por ejemplo, texto (0), imagen (1), vídeo (2). Los ids de tipo de token multimodal se pueden obtener usando AutoProcessor. Consulte ProcessorMixin.call() para más detalles.
  • inputs_embeds (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
  • image_position_ids (torch.LongTensor de forma (batch_size, max_patches, 2), opcional) — Coordenadas de posición 2D de los parches procedentes del procesador de imágenes, donde (-1, -1) indica relleno. Se transmite al codificador visual para el cálculo de los embeddings posicionales.
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

Devuelve

BaseModelOutputWithPast o tuple(torch.FloatTensor)

Un BaseModelOutputWithPast o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DiffusionGemmaConfig) y las entradas.

El método forward de DiffusionGemmaEncoderModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

DiffusionGemmaEncoderTextModel

clase transformers.DiffusionGemmaEncoderTextModel

< >

( config: DiffusionGemmaTextConfig )

forward

< >

( 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.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.

    Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • attention_mask (Union[torch.Tensor, dict] de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • inputs_embeds (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

Devuelve

BaseModelOutputWithPast o tuple(torch.FloatTensor)

Un BaseModelOutputWithPast o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DiffusionGemmaConfig) y las entradas.

El método forward de DiffusionGemmaEncoderTextModel sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

    Si se utiliza past_key_values, solo se genera el último hidden-state de las secuencias con forma (batch_size, 1, hidden_size).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

DiffusionGemmaDecoderModel

clase transformers.DiffusionGemmaDecoderModel

< >

( config: DiffusionGemmaConfig )

Modelo decodificador para DiffusionGemma.

Procesa los tokens del lienzo con autoatención bidireccional y atención cruzada con la caché KV del codificador. El decodificador lee la caché KV pero no la actualiza. Excluyendo estas diferencias, es similar a DiffusionGemmaEncoderTextModel, y comparten todos los pesos que tienen en común.

forward

< >

( decoder_input_ids: LongTensorpast_key_values: transformers.cache_utils.Cache | None = Noneself_conditioning_logits: typing.Optional[torch.FloatTensor] = 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.FloatTensor)

Parámetros

  • decoder_input_ids (torch.LongTensor de forma (batch_size, canvas_length)) — IDs de tokens para el lienzo que se va a refinar.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • self_conditioning_logits (torch.FloatTensor de forma (batch_size, canvas_length, vocab_size), opcional) — Logits de autocondicionamiento del paso de desruido anterior, utilizados para calcular los embeddings de autocondicionamiento.
  • self_conditioning_mask (torch.BoolTensor de forma (batch_size,), opcional) — Máscara por ejemplo sobre self_conditioning_logits: los ejemplos fijados en False reciben una señal de autocondicionamiento a cero, como si no se hubieran pasado logits para ellos. Útil para el entrenamiento, donde el autocondicionamiento se habilita por ejemplo con cierta probabilidad.
  • decoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length+canvas_length) o dict, opcional) — Máscara de atención para la caché KV del decodificador. Se utiliza para especificar las entradas de la caché KV del codificador rellenas o sin poblar.
  • decoder_position_ids (torch.LongTensor de forma (batch_size, canvas_length), opcional) — Los IDs de posición para los tokens en el lienzo.

Devuelve

BaseModelOutput o tuple(torch.FloatTensor)

Un BaseModelOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DiffusionGemmaConfig) y las entradas.

El método forward de DiffusionGemmaDecoderModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

DiffusionGemmaForBlockDiffusion

clase transformers.DiffusionGemmaForBlockDiffusion

< >

( config: DiffusionGemmaConfig )

Modelo DiffusionGemma para difusión por bloques. Llama a DiffusionGemmaModel para obtener los estados ocultos del lienzo de entrada, condicionados por una caché KV del prompt. Utilizando su LM Head y sus bloques de autocondicionamiento, convierte esos estados ocultos en logits para muestrear el siguiente lienzo, así como los embeddings de autocondicionamiento para el siguiente paso de difusión por bloques.

forward

< >

( 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.FloatTensor] = 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.FloatTensor)

Parámetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — IDs de tokens no cacheados para el prompt que se codificará como contexto para el lienzo.
  • attention_mask (torch.LongTensor de forma (batch_size, sequence_length) o dict, opcional) — Máscara para los tokens de entrada.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en la past_key_values devuelta por el modelo en una etapa anterior de la decodificación, cuando use_cache=True o config.use_cache=True.

    Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan past_key_values, DynamicCache se inicializará de forma predeterminada.

    El modelo generará el mismo formato de caché que se proporciona como entrada.

    Si se utilizan past_key_values, se espera que el usuario introduzca únicamente los input_ids no procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma (batch_size, unprocessed_length) en lugar de todos los input_ids con forma (batch_size, sequence_length).

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, canvas_length), opcional) — IDs de tokens para el lienzo que se va a refinar.
  • self_conditioning_logits (torch.FloatTensor de forma (batch_size, canvas_length, vocab_size), opcional) — Logits de autocondicionamiento del paso de desruido anterior, utilizados para calcular los embeddings de autocondicionamiento.
  • self_conditioning_mask (torch.BoolTensor de forma (batch_size,), opcional) — Máscara por ejemplo sobre self_conditioning_logits: los ejemplos fijados en False reciben una señal de autocondicionamiento a cero, como si no se hubieran pasado logits para ellos. Útil para el entrenamiento, donde el autocondicionamiento se habilita por ejemplo con cierta probabilidad.
  • decoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length+canvas_length) o dict, opcional) — Máscara de atención para la caché KV del decodificador. Se utiliza para especificar las entradas de la caché KV del codificador rellenas o sin poblar.
  • decoder_position_ids (torch.LongTensor de forma (batch_size, canvas_length), opcional) — Los IDs de posición para los tokens en el lienzo.
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Diccionario donde las claves son las modalidades admitidas y los valores son las salidas codificadas para esa modalidad. Cada salida codificada es una tupla que consiste en (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) es una secuencia de características multimodales del codificador fusionadas en las incrustaciones de texto.

Devuelve

DiffusionGemmaBlockDiffusionOutputWithPast o tuple(torch.FloatTensor)

Un DiffusionGemmaBlockDiffusionOutputWithPast o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DiffusionGemmaConfig) y las entradas.

El método forward de DiffusionGemmaForBlockDiffusion sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.FloatTensor de forma (1,), opcional) — Pérdida de modelado de lenguaje.

  • logits (torch.FloatTensor de forma (batch_size, canvas_length, config.text_config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).

  • past_key_values (Cache, opcional, se devuelve cuando se pasa use_cache=True o cuando config.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.

    Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada past_key_values) para acelerar la decodificación secuencial.

  • hidden_states (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

  • encoder_last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Solo se establece cuando se proporciona input_ids, por ejemplo, para calcular una pérdida autorregresiva en el codificador durante el entrenamiento.

Ejemplo:

>>> 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]
Update on GitHub

←DePlot Donut→