# DiffusionGemma

## Обзор

DiffusionGemma спроектирована для снижения последовательных узких мест стандартных каузальных языковых моделей. Она использует архитектуру «кодировщик-декодировщик», специально оптимизированную для скорости вывода.

Кодер работает в режиме prefill, обрабатывая начальный промпт и генерируя KV-кэш. Затем декодер использует двунаправленное внимание для обработки входного блока (канваса) токенов, обращаясь к закэшированному контексту через cross-attention.

На этапе инференса DiffusionGemma использует многоканвасное сэмплирование. Вместо генерации токенов по одному модель итеративно удаляет шум из целого блока токенов с помощью диффузионного сэмплера. После того как канвас полностью очищен от шума, он обрабатывается энкодером и добавляется в KV-кэш, после чего модель генерирует следующий канвас. Такой блочно-авто регрессивный подход позволяет генерировать текст с большей скоростью.

Карточку модели и контрольную точку можно найти [здесь](https://huggingface.co/google/diffusiongemma-26B-A4B-it). Визуальное руководство по модели доступно [здесь](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma).

## Примеры использования

Несмотря на то, что это текстовая диффузионная модель с собственным циклом генерации, большая часть интерфейса совпадает с другими моделями, способными генерировать текст с помощью [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). Если вы используете другую модель `transformers` в вашем приложении, вы сможете напрямую заменить её на эту модель.

> [!NOTE]
> DiffusionGemma доступна как в Transformers, так и в Diffusers, однако основным местом её разработки является Diffusers. Именно в Diffusers представлен полный набор вариантов планировщиков, утилиты конвейеров и новые функции (дополнительные планировщики, критерии остановки, стратегии выборки). Примеры использования см. в документации [DiffusionGemma](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma), а для экспериментов с различными планировщиками или запроса новой функции создайте [issue](https://github.com/huggingface/diffusers/issues) в репозитории Diffusers. Реализация в Transformers получает только исправления ошибок, но не новые функции.

### Частые проблемы

- DiffusionGemma не принимает `use_cache`. Он всегда использует KV-кэш;
- Поддержка распространённых флагов, таких как `top_k`, не будет доступна в день релиза, но будет добавлена со временем, если они совместимы с текстовой диффузией.

### Базовый пример

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

### Потоковая передача

Как и в случае с другими моделями, способными генерировать текст, вы можете задать класс стримера для потоковой передачи текста. В отличие от других моделей, DiffusionGemma генерирует промежуточные черновики до получения финального текста. Вы можете визуализировать их с помощью `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)
```

### Задание начального вывода для шумоподавления

Модель обучена итеративно уточнять блоки из 256 токенов. В некоторых приложениях может быть полезно задать начальную точку для декодера, а не начинать с случайных токенов. Вы можете использовать `decoder_input_ids`, доступный во всех интерфейсах моделей, чтобы задать стартовый холст.

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L35)

**Параметры:**

vocab_size (`int`, *необязательный*, по умолчанию `262144`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

hidden_size (`int`, *необязательный*, по умолчанию `2304`) : Размерность скрытых представлений.

intermediate_size (`int`, *необязательный*, по умолчанию `9216`) : Размерность представлений MLP.

num_hidden_layers (`int`, *необязательный*, по умолчанию `30`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

num_key_value_heads (`int`, *optional*, по умолчанию `4`) : Это количество ключевых и value-голов, которое следует использовать для реализации Grouped Query Attention. Если `num_key_value_heads=num_attention_heads`, модель будет использовать Multi Head Attention (MHA), если `num_key_value_heads=1` — Multi Query Attention (MQA), в противном случае используется GQA. При конвертации multi-head checkpoint в GQA checkpoint каждая группа ключевых и value-голов должна быть построена путем усреднения (meanpooling) всех исходных голов в этой группе. Подробнее см. в [этой статье](https://huggingface.co/papers/2305.13245). Если значение не указано, по умолчанию используется `num_attention_heads`.

head_dim (`int`, *необязательный*, по умолчанию `256`) : Размер измерения головы внимания. Если None, по умолчанию будет hidden_size // num_attention_heads

hidden_activation (`str`, *необязательный*, по умолчанию `gelu_pytorch_tanh`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

max_position_embeddings (`int`, *необязательный*, по умолчанию `131072`) : Максимальная длина последовательности, с которой может использоваться эта модель.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

rms_norm_eps (`float`, *необязательный*, по умолчанию `1e-06`) : Значение epsilon, используемое слоями нормализации rms.

pad_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для выравнивания в словаре.

eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `1`) : Идентификатор токена, используемого для обозначения конца потока в словаре.

bos_token_id (`int`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемый для обозначения начала потока в словаре.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

rope_parameters (`dict`, *необязательный*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`.

attention_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

attention_dropout (`Union[int, float]`, *необязательный*, по умолчанию `0.0`) : Доля dropout для вероятностей внимания.

sliding_window (`int`, *optional*, по умолчанию `512`) : Размер окна скользящего внимания. Если `None`, скользящее окно не применяется.

layer_types (`list[str]`, *необязательный*) : Список, который явно сопоставляет каждый индекс слоя с его типом. Если не указан, будет автоматически сгенерирован на основе значений конфигурации.

use_bidirectional_attention (`str`, *необязательный*) : Управляет поведением двунаправленного внимания. При значении `"vision"` визуальные токены используют двунаправленное внимание, а текстовые — каузальное. При значении `"all"` все токены используют двунаправленное внимание.

num_experts (`int`, *необязательный*) : Количество маршрутизируемых экспертов в слоях MoE.

top_k_experts (`int`, *необязательный*) : Количество экспертов, активируемых на каждый токен в слоях MoE.

moe_intermediate_size (`int`, *optional*) : Промежуточный (скрытый) размер сети прямого распространения каждого эксперта в слоях MoE.

Это класс конфигурации для хранения настроек модели DiffusionGemmaModel. Он используется для создания модели Diffusion Gemma в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

## 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/configuration_diffusion_gemma.py#L162)

**Параметры:**

text_config (`Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]]`, *необязательный*) : Объект конфигурации или словарь текстового бэкбона.

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *необязательный*) : Объект конфигурации или словарь визуального бэкбона.

boi_token_id (`int`, *optional*, по умолчанию 255999) : Индекс токена начала изображения, используемого для обрамления изображения-подсказки.

eoi_token_id (`int`, *optional*, по умолчанию 258882) : Индекс токена конца изображения, используемого для обрамления изображения-подсказки.

image_token_id (`int`, *необязательный*, по умолчанию `258880`) : Индекс токена изображения, используемый как плейсхолдер для входных изображений.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

canvas_length (`int`, *optional*, по умолчанию 256) : Размер холста или, другими словами, длина блока в блочной диффузии. Используется для инициализации пустого холста.

Это класс конфигурации для хранения настроек модели DiffusionGemmaModel. Он используется для создания модели Diffusion Gemma в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L247)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size, sequence_length)`) : сгенерированные последовательности, включая промпт, если `input_ids` был передан в метод `generate`.

tokens_per_forward (`torch.LongTensor` формы (`batch_size`)) : Количество токенов на каждый проход в этом вызове `generate` для каждого элемента в батче. Часто используется как вторичная метрика оценки для моделей текстовой диффузии.

past_key_values (`Cache`) : кэш, используемый для генерации. Его можно передавать в последующие вызовы `generate`, чтобы ускорить генерацию в многораундовых сессиях.

logits (`None`) : Не используется. Оставлено в интерфейсе для обратной совместимости.

scores (`None`) : Не используется. Оставлено в интерфейсе для обратной совместимости.

hidden_states (`None`) : Не используется. Оставлено в интерфейсе для обратной совместимости.

Класс результата для генерации в DiffusionGemma.

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L543)

Класс-миксин для генерации в DiffusionGemma. Содержит все методы на уровне модели.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L548)

**Параметры:**

input_ids (*torch.LongTensor* формы *(batch_size, sequence_length)*, *необязательный*) : Последовательность, используемая как промпт для генерации.

past_key_values ([Кэш](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), *необязательный*) : объект Cache, содержащий прошлые значения ключей и прошлые маски внимания для декодера. Если он задан, `input_ids` и/или `pixel_values` должны соответствовать только данным, не находящимся в кэше.

streamer (`BaseStreamer`, *необязательный*) : объект Streamer, который будет использоваться для потоковой передачи сгенерированных последовательностей. Сгенерированные токены передаются через `streamer.put(token_ids)`, а дальнейшая обработка является ответственностью streamer. Если объект streamer имеет метод `put_draft`, токены из шагов денойзинга будут отправляться туда.

**Дополнительные аргументы для опытных пользователей:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *необязательный*) : Конфигурация генерации, используемая в качестве базовой параметризации для вызова генерации, с переопределением значений по умолчанию модели. Если в контрольной точке модели есть файл `generation_config.json`, значения по умолчанию модели будут загружены из него. В противном случае будет создан пустой экземпляр `DiffusionGemmaGenerationConfig`. В качестве дополнительного сокращения, `**kwargs`, соответствующие атрибутам в `generation_config`, переопределяют их.

logits_processor ([LogitsProcessorList](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.LogitsProcessorList), *optional*) : Пользовательские обработчики logits, дополняющие стандартные обработчики logits, создаваемые на основе аргументов и конфигурации генерации, которые применяются к logits диффузии. Если указаны, эти обработчики будут применены первыми. Эта функция предназначена для опытных пользователей. Например, вы можете передать сюда обработчики logits, обычно используемые с AR LLM.

stopping_criteria ([StoppingCriteriaList](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.StoppingCriteriaList), *optional*) : Пользовательские критерии остановки, дополняющие стандартные критерии остановки блочного авто-регрессивного генерирования, формируемые на основе аргументов и конфигурации генерирования. Если указаны, эти критерии применяются в первую очередь. Эта функция предназначена для опытных пользователей. Например, вы можете передать сюда критерии остановки, обычно используемые с AR-LLM.

kwargs (`dict[str, Any]`, *необязательный*) : Произвольная параметризация `generation_config` и/или дополнительные модельно-специфичные kwargs, которые будут переданы в функцию `forward` модели. Например, вы можете задать стартовый холст с помощью `decoder_input_ids`.

**Возвращает:** `torch.LongTensor` или [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: сгенерированный текст в виде идентификаторов.
- [DiffusionGemmaGenerationOutput](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput): экземпляр `ModelOutput`, содержащий сгенерированный текст (`sequences`), а также другие необязательные выходные данные.

Генерирует текст с помощью диффузионной модели.

Он содержит внешний цикл, выполняющий авторегрессионную генерацию холстов (блоков токенов), и внутренний

цикл, выполняющий диффузию на каждом холсте. Алгоритм работает примерно следующим образом:
```
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
```

Примеры:

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L55)

**Параметры, управляющие длиной вывода:**

max_new_tokens (`int`, *optional*) : Максимальное количество токенов для генерации, не учитывая количество токенов в промпте.

max_length (`int`, *optional*) : Максимальная длина выходной последовательности. Для управления количеством токенов, генерируемых моделью, рекомендуется использовать `max_new_tokens`.

**Параметры диффузии:**

max_denoising_steps (`int`) : Максимальное количество шагов денойзинга.

sampler_config (`EntropyBoundSamplerConfig`) : конфигурация сэмплера. См. [EntropyBoundSampler](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.EntropyBoundSampler), чтобы узнать, как работает сэмплер в текстовой диффузионной модели.

t_min (`float`) : Итоговая температура в расписании, то есть на последнем шаге денойзинга. Подробности см. в [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor).

t_max (`float`) : Начальная температура в расписании, то есть на первом шаге денойзинга. Подробности см. в [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor).

stability_threshold (`int`) : Количество шагов, в течение которых принятый холст должен оставаться неизменным для срабатывания критерия остановки. Подробнее см. в [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria).

confidence_threshold (`float`) : Порог для среднего значения энтропии логитов с масштабированием по температуре, при котором срабатывают критерии остановки. Подробнее см. [StableAndConfidentStoppingCriteria](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria).

**Параметры, управляющие кэшем:**

cache_implementation (`str`, *необязательный*) : Имя класса кэша, который будет создан в `generate` для более быстрого декодирования. Возможные значения:  - `"dynamic"`: [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.QuantizedCache)  Если значение не указано, будет использоваться кэш по умолчанию для модели (часто это [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache)). Дополнительную информацию см. в [документации по кэшированию](https://huggingface.co/docs/transformers/en/kv_cache).

cache_config (`dict`, *необязательный*, по умолчанию `None`) : Аргументы, используемые в классе кэша ключ-значение, можно передать в `cache_config`.

**Специальные токены, которые можно использовать при генерации:**

bos_token_id (`int`, *необязательный*) : идентификатор токена *beginning-of-sequence*.

pad_token_id (`int`, *необязательный*) : идентификатор токена *padding*.

eos_token_id (`Union[int, list[int]]`, *необязательный*) : Идентификатор токена *конца последовательности*. При необходимости можно использовать список, чтобы задать несколько токенов *конца последовательности*.

Класс GenerationConfig с параметризацией, настроенной для [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate).

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L320)

**Параметры:**

entropy_bound (`float`) : Граница энтропии. Чем выше это значение, тем больше токенов будет принято. Подробнее о том, как она применяется, см. в docstring [EntropyBoundSampler.accept_canvas()](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas).

Класс конфигурации для сэмплера с ограничением по энтропии.

## EntropyBoundSampler[[transformers.EntropyBoundSampler]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L343)

**Параметры:**

config (`EntropyBoundSamplerConfig`) : конфигурация сэмплера.

canvas_length (`int`) : Длина холста.

vocab_size (`int`) : Размер словаря.

max_denoising_steps (`int`) : Максимальное количество шагов денойзинга. (Не используется в этом сэмплере)

Класс сэмплера, который инициализирует холст случайными токенами, принимает токены на основе энтропии на уровне токенов и повторно добавляет шум к непринятым токенам.

Ниже приведена приблизительная схема работы цикла сэмплера:
```
          +-----------------------+
          | 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)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L406)

**Параметры:**

current_canvas (`torch.LongTensor`) : Текущий холст.

denoiser_canvas (`torch.LongTensor`) : холст, полученный из предсказаний денойзера.

logits (`torch.Tensor`) : логиты из денойзера.

cur_step (`int`) : Текущий шаг.

**Возвращает:** `torch.LongTensor`

Принятый холст.

Принимает токены из денойзера на основе порога энтропии. Более конкретно, выборка выполняется путём принятия k токенов с наименьшей энтропией, таких что

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

где левая часть представляет собой верхнюю границу совместной взаимной информации между этими токенами, и, следовательно, сэмплер выбирает k токенов, которые являются приблизительно независимыми.

Изначально предложен в https://arxiv.org/pdf/2505.24857

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L394)

Инициализирует и возвращает новый холст из `canvas_length` токенов со случайными значениями из словаря.

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L450)

**Параметры:**

accepted_canvas (`torch.LongTensor`) : Принятый холст.

cur_step (`int`) : Текущий шаг. (Не используется в этом сэмплере)

**Возвращает:** `torch.LongTensor`

Повторно зашумлённый холст.

Повторно генерирует все не принятые токены.

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L484)

**Параметры:**

stability_threshold (`int`) : Количество шагов, в течение которых принятый холст должен оставаться неизменным для срабатывания критерия остановки.

confidence_threshold (`float`) : Порог для среднего значения энтропии логитов, масштабированных по температуре, для срабатывания критерия остановки.

Адаптивная стратегия остановки, которая прекращает процесс, когда диффузионный процесс становится уверенным и стабильным. Более конкретно:
- Процесс диффузии считается стабильным, если принятый холст остаётся неизменным на протяжении `stability_threshold` шагов.
- Процесс диффузии считается уверенным, если среднее значение энтропии обработанных логитов ниже `confidence_threshold`.

## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/generation_diffusion_gemma.py#L276)

**Параметры:**

t_min (`float`) : Итоговая температура в расписании, то есть на последнем шаге удаления шума.

t_max (`float`) : Начальная температура в расписании, то есть на первом шаге денойзинга.

max_denoising_steps (`int`) : Максимальное количество шагов денойзинга.

Обработчик логитов, применяющий линейное расписание температуры к логитам. Это похоже на `TemperatureLogitsWarper`, за исключением того, что температура является функцией текущего шага.

На шаге n из N температура t задается формулой t = t_min + ((t_max - t_min) * (n/N)).

## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L817)

**Параметры:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

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

```python
forward(*args, **kwargs)
```

Мок-значение для пути с точками (например, `torch.float32`): цепочки доступа к атрибутам и вызовы работают как пропускные декораторы, `repr` возвращает путь с точками, а использование в качестве базового класса подменяет его обычным базовым классом `type` (PEP 560 `__mro_entries__`), благодаря чему реальные дочерние классы сохраняют обычный метакласс, а `inspect.signature` читает их реальный `__init__`, а не мок.

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1452)

**Параметры:**

config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Diffusion Gemma без дополнительных компонентов, выводящая необработанные скрытые состояния (raw hidden-states) без какого-либо специализированного слоя (head) сверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1494)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Некешированные идентификаторы токенов для промпта, который будет закодирован в качестве контекста для холста.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)` или `dict`, *необязательный*) : Маска для входных токенов.

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`, *необязательный*) : Идентификаторы токенов для холста, который будет уточнен.

self_conditioning_logits (`torch.Tensor` формы `(batch_size, canvas_length, vocab_size)`, *необязательный*) : Логиты самоусловления от предыдущего шага денойзинга, используемые для вычисления эмбеддингов самоусловления.

self_conditioning_mask (`torch.BoolTensor` формы `(batch_size,)`, *необязательный*) : Маска для каждого примера в `self_conditioning_logits`: для примеров, установленных в `False`, сигнал самоусловления обнуляется, как если бы для них не были переданы логиты. Полезно при обучении, когда самоусловление включается для каждого примера с некоторой вероятностью.

decoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length+canvas_length)` или `dict`, *необязательный*) : Маска внимания для KV-кэша декодера. Используется для указания заполненных/незаполненных записей в кэше KV энкодера.

decoder_position_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`, *необязательный*) : Позиционные идентификаторы для токенов в канве.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *необязательный*) : Словарь, где ключами являются поддерживаемые модальности, а значениями — закодированные выходные данные для данной модальности. Каждый закодированный выход представляет собой кортеж, состоящий из (`pooler_output`, *необязательный*: `last_hidden_states`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `pooler_output` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) — это последовательность мультимодальных признаков энкодера, объединенных в текстовые эмбеддинги.

**Возвращает:** `DiffusionGemmaModelOutputWithPast` или `tuple(torch.Tensor)`

Объект `DiffusionGemmaModelOutputWithPast` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) и входных данных.

Метод forward модели [DiffusionGemmaModel](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.

  Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера. Задается только при предоставлении `input_ids`, например, для вычисления авторегрессионной функции потерь для энкодера во время обучения.

## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L995)

**Параметры:**

config ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель-энкодер DiffusionGemma, включающая визуальный бэкбон и языковую модель, *без* головы для моделирования языка. Она очень похожа на Gemma4Model, за исключением того, что не поддерживает аудио- и видеовход и всегда использует путь MoE во внутренних слоях.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1060)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` ([Gemma4Processor](/docs/transformers/v5.23.0/ru/model_doc/gemma4#transformers.Gemma4Processor) использует `image_processor_class` для обработки изображений).

attention_mask (`Union[torch.Tensor, dict]` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

mm_token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности, соответствующие каждой модальности. Например, текст (0), изображение (1), видео (2). Идентификаторы типов мультимодальных токенов можно получить с помощью [AutoProcessor](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoProcessor). Подробности см. в [ProcessorMixin.__call__()](/docs/transformers/v5.23.0/ru/main_classes/processors#transformers.ProcessorMixin.__call__).

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

image_position_ids (`torch.LongTensor` формы `(batch_size, max_patches, 2)`, *необязательный*) : координаты позиций 2D-патчей от обработчика изображений, где `(-1, -1)` обозначает заполнение. Передаётся в визуальный энкодер для вычисления позиционных эмбеддингов.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *необязательный*) : Словарь, где ключами являются поддерживаемые модальности, а значениями — закодированные выходные данные для данной модальности. Каждый закодированный выход представляет собой кортеж, состоящий из (`pooler_output`, *необязательный*: `last_hidden_states`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `pooler_output` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) — это последовательность мультимодальных признаков энкодера, объединенных в текстовые эмбеддинги.

**Возвращает:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или `tuple(torch.Tensor)`

Объект [BaseModelOutputWithPast](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) и входных данных.

Метод forward модели [DiffusionGemmaEncoderModel](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.

  Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L881)

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L909)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

attention_mask (`Union[torch.Tensor, dict]` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

**Возвращает:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или `tuple(torch.Tensor)`

Объект [BaseModelOutputWithPast](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) и входных данных.

Метод forward модели [DiffusionGemmaEncoderTextModel](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.

  Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1175)

Модель декодера для DiffusionGemma.

Обрабатывает токены холста с использованием двунаправленного само-внимания и кросс-внимания к кэшу KV энкодера. Декодер читает кэш KV, но не обновляет его. За исключением этих различий, модель похожа на `DiffusionGemmaEncoderTextModel`, и они разделяют все общие веса.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1217)

**Параметры:**

decoder_input_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`) : Идентификаторы токенов для холста, который будет уточнен.

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

self_conditioning_logits (`torch.Tensor` формы `(batch_size, canvas_length, vocab_size)`, *необязательный*) : Логиты самоусловления от предыдущего шага денойзинга, используемые для вычисления эмбеддингов самоусловления.

self_conditioning_mask (`torch.BoolTensor` формы `(batch_size,)`, *необязательный*) : Маска для каждого примера в `self_conditioning_logits`: для примеров, установленных в `False`, сигнал самоусловления обнуляется, как если бы для них не были переданы логиты. Полезно при обучении, когда самоусловление включается для каждого примера с некоторой вероятностью.

decoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length+canvas_length)` или `dict`, *необязательный*) : Маска внимания для KV-кэша декодера. Используется для указания заполненных/незаполненных записей в кэше KV энкодера.

decoder_position_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`, *необязательный*) : Позиционные идентификаторы для токенов в канве.

**Возвращает:** [BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или `tuple(torch.Tensor)`

Объект [BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) и входных данных.

Метод forward модели [DiffusionGemmaDecoderModel](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1579)

Модель DiffusionGemma для блочной диффузии. Она вызывает `DiffusionGemmaModel` для получения скрытых состояний входного холста, обусловленных KV-кэшем промпта. С помощью своего LM Head и блоков самоусловливания она преобразует эти скрытые состояния в логиты для выборки следующего холста, а также в эмбеддинги самоусловливания для следующего шага блочной диффузии.

#### 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'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/diffusion_gemma/modeling_diffusion_gemma.py#L1601)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Некешированные идентификаторы токенов для промпта, который будет закодирован в качестве контекста для холста.

attention_mask (`torch.LongTensor` формы `(batch_size, sequence_length)` или `dict`, *необязательный*) : Маска для входных токенов.

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`, *необязательный*) : Идентификаторы токенов для холста, который будет уточнен.

self_conditioning_logits (`torch.Tensor` формы `(batch_size, canvas_length, vocab_size)`, *необязательный*) : Логиты самоусловления от предыдущего шага денойзинга, используемые для вычисления эмбеддингов самоусловления.

self_conditioning_mask (`torch.BoolTensor` формы `(batch_size,)`, *необязательный*) : Маска для каждого примера в `self_conditioning_logits`: для примеров, установленных в `False`, сигнал самоусловления обнуляется, как если бы для них не были переданы логиты. Полезно при обучении, когда самоусловление включается для каждого примера с некоторой вероятностью.

decoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length+canvas_length)` или `dict`, *необязательный*) : Маска внимания для KV-кэша декодера. Используется для указания заполненных/незаполненных записей в кэше KV энкодера.

decoder_position_ids (`torch.LongTensor` формы `(batch_size, canvas_length)`, *необязательный*) : Позиционные идентификаторы для токенов в канве.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *необязательный*) : Словарь, где ключами являются поддерживаемые модальности, а значениями — закодированные выходные данные для данной модальности. Каждый закодированный выход представляет собой кортеж, состоящий из (`pooler_output`, *необязательный*: `last_hidden_states`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `pooler_output` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) — это последовательность мультимодальных признаков энкодера, объединенных в текстовые эмбеддинги.

**Возвращает:** `DiffusionGemmaBlockDiffusionOutputWithPast` или `tuple(torch.Tensor)`

Объект `DiffusionGemmaBlockDiffusionOutputWithPast` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DiffusionGemmaConfig](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) и входных данных.

Метод forward класса [DiffusionGemmaForBlockDiffusion](/docs/transformers/v5.23.0/ru/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*) -- Потеря языковой модели.
- **logits** (`torch.Tensor` формы `(batch_size, canvas_length, config.text_config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax).
- **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера. Задается только при предоставлении `input_ids`, например, для вычисления авторегрессионной функции потерь для энкодера во время обучения.

Пример:

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

