# 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é mediante 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í](https://huggingface.co/google/diffusiongemma-26B-A4B-it). Puedes encontrar una guía visual del modelo [aquí](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma).

## 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()](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). Si estás utilizando otro modelo de `transformers` en tu aplicación, deberías poder reemplazarlo directamente por este modelo.

> [!NOTE]
> 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](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) para ver ejemplos de uso y abre un [issue](https://github.com/huggingface/diffusers/issues) 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

```python
from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor

model = DiffusionGemmaForBlockDiffusion.from_pretrained(
    "google/diffusiongemma-26B-A4B-it", device_map="auto",
)
processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "What is shown in this image?"},
        ]
    },
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    # Add the following to enable thinking
    # enable_thinking=True,
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Set `cache_implementation="static"` in `generate` to trigger `torch.compile`.
# Compilation is much faster, after warming up!
output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output.sequences[0][input_len:], skip_special_tokens=True))
```

### Streaming

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`

```python
from transformers import TextDiffusionStreamer

# (... copy from the example above, up to the `generate` call)
streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
model.generate(**inputs, max_new_tokens=256, streamer=streamer)
```

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

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

## DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

#### transformers.DiffusionGemmaTextConfig[[transformers.DiffusionGemmaTextConfig]]

```python
transformers.DiffusionGemmaTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 262144, hidden_size: int = 2304, intermediate_size: int = 9216, num_hidden_layers: int = 30, num_attention_heads: int = 8, num_key_value_heads: int = 4, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, tie_word_embeddings: bool = True, rope_parameters: dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int = 512, layer_types: list[str] | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = None, num_experts: int | None = None, top_k_experts: int | None = None, moe_intermediate_size: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L35)

**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 del Transformer.

num_key_value_heads (`int`, *opcional*, valor predeterminado `4`) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). 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 se podría utilizar este modelo.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de 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 de token utilizado para el relleno en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*, valor predeterminado `1`) : Id del token utilizado para el fin de la secuencia en el vocabulario.

bos_token_id (`int`, *opcional*, valor predeterminado `2`) : Identificador de token utilizado para el inicio de la secuencia en el vocabulario.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos 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, 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`) : Indica 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 mapea 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 utilizan atención bidireccional, mientras que los tokens de texto usan atención causal. Cuando se establece en `"all"`, todos los tokens utilizan 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](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

#### transformers.DiffusionGemmaConfig[[transformers.DiffusionGemmaConfig]]

```python
transformers.DiffusionGemmaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True, canvas_length: int | None = 256)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L163)

**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) : El í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 de truncated_normal_initializer para inicializar todas las matrices de pesos.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos 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](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```python
>>> from transformers import (
>>>     DiffusionGemmaConfig,
>>>     DiffusionGemmaModel,
>>>     DiffusionGemmaTextConfig,
>>>     Gemma4VisionConfig,
>>> )

>>> # Initializing a DiffusionGemma Text config.
>>> text_config = DiffusionGemmaTextConfig()

>>> # Initializing a Gemma 4 vision config (DiffusionGemma uses Gemma 4's vision block).
>>> vision_config = Gemma4VisionConfig()

>>> # Initializing a DiffusionGemma text config
>>> configuration = DiffusionGemmaConfig(text_config, vision_config)

>>> # Initializing a model from the configuration
>>> model = DiffusionGemmaModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

#### transformers.DiffusionGemmaGenerationOutput[[transformers.DiffusionGemmaGenerationOutput]]

```python
transformers.DiffusionGemmaGenerationOutput(sequences: LongTensor, tokens_per_forward: int | None = None, past_key_values: transformers.cache_utils.Cache | None = None, logits: None = None, scores: None = None, hidden_states: None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L247)

**Parámetros:**

sequences (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Las secuencias generadas, que incluyen 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 pasada en esta llamada a `generate`, para cada miembro del lote. 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`) : Sin uso. Se mantiene en la interfaz por compatibilidad hacia atrás.

scores (`None`) : Sin uso. Se mantiene en la interfaz por compatibilidad hacia atrás.

hidden_states (`None`) : Sin uso. Se mantiene en la interfaz por compatibilidad hacia atrás.

Clase de salida para la generación de DiffusionGemma.

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

#### transformers.DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

```python
transformers.DiffusionGemmaGenerationMixin()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L543)

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

#### generate[[transformers.DiffusionGemmaGenerationMixin.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, streamer: transformers.generation.streamers.BaseStreamer | None = None, generation_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L548)

**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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache), *opcional*) : Objeto Cache 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 Streamer que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de `streamer.put(token_ids)` y el streamer se encarga de cualquier procesamiento adicional. Si el objeto streamer tiene un método `put_draft`, los tokens de los pasos de desruido se enviarán allí.

**Argumentos adicionales para usuarios avanzados:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessorList), *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados 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](/docs/transformers/main/es/internal/generation_utils#transformers.StoppingCriteriaList), *optional*) : Criterios de parada personalizados que complementan los criterios de parada autoregresivos por defecto del bloque, 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](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: el texto generado en ids.
- [DiffusionGemmaGenerationOutput](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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:

```python
>>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(
...     "google/diffusiongemma-26B-A4B-it", device_map="auto",
>>> )

>>> chat = [{"role": "user", "content": "Why is the sky blue?"},]
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> input_ids = processor.apply_chat_template(chat, tokenize=True, return_tensors="pt")

>>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
>>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer)
```

## DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

#### transformers.DiffusionGemmaGenerationConfig[[transformers.DiffusionGemmaGenerationConfig]]

```python
transformers.DiffusionGemmaGenerationConfig(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L55)

**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](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) para más detalles.

t_max (`float`) : La temperatura inicial en el programa, es decir, en el primer paso de desruido. Consulte [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) para obtener 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](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/es/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/es/internal/generation_utils#transformers.QuantizedCache)  Si no se especifica ninguno, se utilizará la caché predeterminada del modelo (que a menudo es [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache)). Consulte nuestra [documentación de caché](https://huggingface.co/docs/transformers/en/kv_cache) para obtener más información.

cache_config (`dict`, *opcional*, valor predeterminado `None`) : Los argumentos utilizados en la clase de caché de clave-valor se pueden pasar 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 *end-of-sequence*. Opcionalmente, use una lista para establecer varios tokens *end-of-sequence*.

Una clase GenerationConfig con parametrización personalizada para [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate).

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

#### transformers.EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

```python
transformers.EntropyBoundSamplerConfig(entropy_bound: float)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L320)

**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()](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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[[transformers.EntropyBoundSampler]]

#### transformers.EntropyBoundSampler[[transformers.EntropyBoundSampler]]

```python
transformers.EntropyBoundSampler(config: EntropyBoundSamplerConfig, canvas_length: int, vocab_size: int, max_denoising_steps: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L343)

**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 sampler que inicializa un lienzo con tokens aleatorios, acepta tokens según la entropía a nivel de token y re-ruidos 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[[transformers.EntropyBoundSampler.accept_canvas]]

```python
accept_canvas(current_canvas: LongTensor, denoiser_canvas: LongTensor, logits: Tensor, cur_step: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L406)

**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.Tensor`) : Los logits del denoiser.

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 los k tokens con 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[[transformers.EntropyBoundSampler.initialize_canvas]]

```python
initialize_canvas(batch_size: int, device: device)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L394)

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

#### renoise_canvas[[transformers.EntropyBoundSampler.renoise_canvas]]

```python
renoise_canvas(accepted_canvas: LongTensor, cur_step: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L450)

**Parámetros:**

accepted_canvas (`torch.LongTensor`) : El lienzo aceptado.

cur_step (`int`) : El paso actual. (No se utiliza en este muestreador)

**Devuelve:** `torch.LongTensor`

El lienzo re-ruido.

Renoisea todos los tokens no aceptados.

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

#### transformers.StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

```python
transformers.StableAndConfidentStoppingCriteria(stability_threshold: int, confidence_threshold: float)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L484)

**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[[transformers.LinearTemperatureScheduleLogitsProcessor]]

#### transformers.LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

```python
transformers.LinearTemperatureScheduleLogitsProcessor(t_min: float, t_max: float, max_denoising_steps: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L276)

**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[[transformers.DiffusionGemmaPreTrainedModel]]

#### transformers.DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

```python
transformers.DiffusionGemmaPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L817)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DiffusionGemmaPreTrainedModel.forward]]

```python
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 simulacro.

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

#### transformers.DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

```python
transformers.DiffusionGemmaModel(config: DiffusionGemmaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1452)

**Parámetros:**

config ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DiffusionGemmaModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1494)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : IDs de tokens sin caché 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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.Tensor` 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 con valor `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 que están 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.Tensor)`

Un `DiffusionGemmaModelOutputWithPast` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) y las entradas.

El método forward de [DiffusionGemmaModel](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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.Tensor` 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[[transformers.DiffusionGemmaEncoderModel]]

#### transformers.DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

```python
transformers.DiffusionGemmaEncoderModel(config: DiffusionGemmaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L995)

**Parámetros:**

config ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo de codificador DiffusionGemma, que incluye 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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DiffusionGemmaEncoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, image_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1060)

**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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` 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 usando `image_processor_class`. Consulte `image_processor_class.__call__` para más detalles ([Gemma4Processor](/docs/transformers/main/es/model_doc/gemma4#transformers.Gemma4Processor) usa `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 la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 mediante [AutoProcessor](/docs/transformers/main/es/model_doc/auto#transformers.AutoProcessor). Consulte [ProcessorMixin.__call__()](/docs/transformers/main/es/main_classes/processors#transformers.ProcessorMixin.__call__) para obtener más detalles.

inputs_embeds (`torch.Tensor` 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 de parches 2D del procesador de imágenes, donde `(-1, -1)` indica relleno. Se transmite al codificador de visión para el cálculo de la incrustación posicional.

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](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) y las entradas.

El método forward de [DiffusionGemmaEncoderModel](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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[[transformers.DiffusionGemmaEncoderTextModel]]

#### transformers.DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

```python
transformers.DiffusionGemmaEncoderTextModel(config: DiffusionGemmaTextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L881)

#### forward[[transformers.DiffusionGemmaEncoderTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L909)

**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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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 la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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.Tensor` 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](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) y las entradas.

El método forward de [DiffusionGemmaEncoderTextModel](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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[[transformers.DiffusionGemmaDecoderModel]]

#### transformers.DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

```python
transformers.DiffusionGemmaDecoderModel(config: DiffusionGemmaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1175)

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[[transformers.DiffusionGemmaDecoderModel.forward]]

```python
forward(decoder_input_ids: LongTensor, past_key_values: transformers.cache_utils.Cache | None = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1217)

**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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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.Tensor` 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 con valor `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 que están 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](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) y las entradas.

El método forward de [DiffusionGemmaDecoderModel](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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[[transformers.DiffusionGemmaForBlockDiffusion]]

#### transformers.DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

```python
transformers.DiffusionGemmaForBlockDiffusion(config: DiffusionGemmaConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1579)

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 las incrustaciones de autocondicionamiento para el siguiente paso de difusión por bloques.

#### forward[[transformers.DiffusionGemmaForBlockDiffusion.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, past_key_values: transformers.cache_utils.Cache | None = None, position_ids: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, self_conditioning_logits: typing.Optional[torch.Tensor] = None, self_conditioning_mask: typing.Optional[torch.BoolTensor] = None, decoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1601)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : IDs de tokens sin caché 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 utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/main/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados 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 las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

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.Tensor` 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 con valor `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 que están 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.Tensor)`

Un `DiffusionGemmaBlockDiffusionOutputWithPast` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([DiffusionGemmaConfig](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) y las entradas.

El método forward de [DiffusionGemmaForBlockDiffusion](/docs/transformers/main/es/model_doc/diffusion_gemma#transformers.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 preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` 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](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (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.Tensor` 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:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained("google/diffusiongemma-26B-A4B-it")
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```