# DiffusionGemma

## Visão geral

O DiffusionGemma foi projetado para reduzir os gargalos sequenciais dos modelos de linguagem causais padrão. Ele emprega uma arquitetura encoder-decoder otimizada especificamente para a velocidade de inferência.

O encoder opera em capacidade de prefill, processando o prompt inicial e gerando o KV cache. Em seguida, o decoder utiliza atenção bidirecional para processar um bloco de entrada (um "canvas") de tokens, acessando o contexto em cache por meio de cross-attention.

Durante a inferência, o DiffusionGemma utiliza amostragem multi-canvas. Em vez de gerar um token de cada vez, o modelo desrujifica iterativamente um bloco completo de tokens usando um amostrador de difusão. Assim que um canvas é totalmente desrujificado, ele é processado pelo codificador e adicionado ao cache KV, após o que o modelo gera o próximo canvas. Essa abordagem autoregressiva por blocos permite a geração de texto em velocidades mais altas.

Você pode encontrar o cartão do modelo e o checkpoint [aqui](https://huggingface.co/google/diffusiongemma-26B-A4B-it). Você pode encontrar um guia visual do modelo [aqui](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-diffusiongemma).

## Exemplos de uso

Apesar de ser um modelo de difusão de texto e possuir um loop de geração personalizado, a maior parte da interface é compartilhada com outros modelos que podem gerar texto com [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate). Se você estiver usando outro modelo do `transformers` no seu aplicativo, deve ser possível substituí-lo diretamente por este modelo.

> [!NOTE]
> O DiffusionGemma está disponível tanto no Transformers quanto no Diffusers, mas o Diffusers é seu principal ambiente. O Diffusers possui o conjunto completo de opções de agendamento, utilitários de pipeline e novos recursos (agendadores adicionais, critérios de parada, estratégias de amostragem) são adicionados apenas nele. Consulte o [DiffusionGemma](https://huggingface.co/docs/diffusers/api/pipelines/diffusion_gemma) para exemplos de uso e abra um [issue](https://github.com/huggingface/diffusers/issues) no Diffusers para experimentar diferentes agendadores ou solicitar um recurso. A implementação no Transformers recebe apenas correções de bugs, mas nenhum novo recurso.

### Observações comuns

- O DiffusionGemma não aceita `use_cache`. Ele sempre usa um cache KV;
- O suporte para flags comuns como `top_k` não estará disponível no dia do lançamento, mas será adicionado ao longo do tempo, caso sejam compatíveis com difusão de texto.

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

Assim como outros modelos que podem gerar texto, você pode definir uma classe de streamer para transmitir o texto. Diferentemente de outros modelos, o DiffusionGemma gera rascunhos intermediários antes do texto final. Você pode visualizá-los com `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)
```

### Definindo uma saída inicial de remoção de ruído

O modelo é treinado para refinar iterativamente blocos de 256 tokens. Em alguns aplicativos, pode ser vantajoso fornecer um ponto de partida para o decodificador, em vez de começar a partir de tokens aleatórios. Você pode usar o `decoder_input_ids`, disponível em todas as interfaces de modelo, para definir o ponto de partida.

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

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

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `262144`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `2304`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `9216`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `30`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

num_key_value_heads (`int`, *opcional*, padrão `4`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

head_dim (`int`, *opcional*, padrão `256`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

hidden_activation (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, padrão `131072`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms.

pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `1`) : ID do token usado para o fim do fluxo no vocabulário.

bos_token_id (`int`, *opcional*, padrão `2`) : ID do token usado para o início do fluxo no vocabulário.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

rope_parameters (`dict`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

attention_dropout (`Union[int, float]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

sliding_window (`int`, *opcional*, padrão `512`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada.

layer_types (`list[str]`, *opcional*) : Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de config.

use_bidirectional_attention (`str`, *opcional*) : Controla o comportamento da atenção bidirecional. Quando definido como `"vision"`, os tokens de visão usam atenção bidirecional, enquanto os tokens de texto usam atenção causal. Quando definido como `"all"`, todos os tokens usam atenção bidirecional.

num_experts (`int`, *opcional*) : Número de especialistas roteados nas camadas MoE.

top_k_experts (`int`, *opcional*) : Número de especialistas ativados por token nas camadas MoE.

moe_intermediate_size (`int`, *opcional*) : Tamanho intermediário (oculto) da rede feed-forward de cada especialista nas camadas MoE.

Esta é a classe de configuração para armazenar a configuração de um DiffusionGemmaModel. Ela é usada para instanciar um modelo Diffusion Gemma de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](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*) : O objeto de configuração ou dicionário do backbone de texto.

vision_config (`Union[~configuration_utils.PreTrainedConfig, dict[str, Any]]`, *opcional*) : O objeto de config ou dicionário do backbone de visão.

boi_token_id (`int`, *opcional*, padrão 255999) : O índice do token de início de imagem para envolver o prompt da imagem.

eoi_token_id (`int`, *opcional*, padrão 258882) : O índice do token de fim de imagem para envolver o prompt da imagem.

image_token_id (`int`, *opcional*, padrão `258880`) : O índice do token de imagem usado como marcador para as imagens de entrada.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

canvas_length (`int`, *opcional*, padrão 256) : O tamanho do canvas ou, em outras palavras, o comprimento do bloco na difusão por blocos. Usado para inicializar um canvas vazio.

Esta é a classe de configuração para armazenar a configuração de um DiffusionGemmaModel. Ela é usada para instanciar um modelo Diffusion Gemma de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [google/diffusiongemma-26B-A4B-it](https://huggingface.co/google/diffusiongemma-26B-A4B-it)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

[Origem](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)`) : As sequências geradas, incluindo o prompt, se `input_ids` foi fornecido ao método `generate`.

tokens_per_forward (`torch.LongTensor` de forma (`batch_size`)) : O número de tokens por forward nesta chamada de `generate`, para cada membro do lote. Isso é frequentemente usado como uma métrica de avaliação secundária para modelos de difusão de texto.

past_key_values (`Cache`) : O cache usado para a geração. Ele pode ser passado para chamadas subsequentes de `generate` para acelerar a geração, em sessões de múltiplas rodadas.

logits (`None`) : Não utilizado. Mantido na interface por compatibilidade.

scores (`None`) : Não utilizado. Mantido na interface por compatibilidade.

hidden_states (`None`) : Não utilizado. Mantido na interface por compatibilidade.

Classe de saída para a geração do DiffusionGemma.

## DiffusionGemmaGenerationMixin[[transformers.DiffusionGemmaGenerationMixin]]

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

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

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

Classe mixin para geração do DiffusionGemma. Contém todos os métodos em nível 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)
```

[Origem](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*) : A sequência usada como prompt para a geração.

past_key_values ([Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache), *opcional*) : Objeto Cache contendo os valores-chave passados e as máscaras de atenção passadas para o decodificador. Se estiver definido, `input_ids` e/ou `pixel_values` devem corresponder apenas a dados não em cache.

streamer (`BaseStreamer`, *opcional*) : Objeto Streamer que será usado para transmitir as sequências geradas. Os tokens gerados são passados por `streamer.put(token_ids)` e o streamer é responsável por qualquer processamento adicional. Se o objeto streamer tiver um método `put_draft`, os tokens das etapas de desruido serão enviados para lá.

**Argumentos adicionais para usuários avançados:**

generation_config ([DiffusionGemmaGenerationConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationConfig), *opcional*) : A configuração de geração a ser usada como parametrização base para a chamada de geração, sobrescrevendo os padrões do modelo. Se o checkpoint do modelo tiver um arquivo `generation_config.json`, o padrão do modelo será carregado a partir dele. Caso contrário, será uma instância vazia de `DiffusionGemmaGenerationConfig`. Como atalho adicional, `**kwargs` que correspondam a atributos em `generation_config` os sobrescreverão.

logits_processor ([LogitsProcessorList](/docs/transformers/main/pt/internal/generation_utils#transformers.LogitsProcessorList), *opcional*) : Processadores de logits personalizados que complementam os processadores de logits padrão criados a partir dos argumentos e da configuração de geração, para serem aplicados nos logits de difusão. Se fornecidos, esses processadores serão os primeiros a serem aplicados. Este recurso é destinado a usuários avançados. Você pode, por exemplo, passar aqui os processadores de logits comumente usados com LLMs AR.

stopping_criteria ([StoppingCriteriaList](/docs/transformers/main/pt/internal/generation_utils#transformers.StoppingCriteriaList), *optional*) : Critérios de parada personalizados que complementam os critérios de parada autoregressivos padrão do bloco, construídos a partir dos argumentos e de uma configuração de geração. Se fornecidos, esses critérios serão aplicados primeiro. Este recurso é destinado a usuários avançados. Por exemplo, você pode passar aqui os critérios de parada comumente usados com LLMs autoregressivos.

kwargs (`dict[str, Any]`, *opcional*) : Parametrização ad hoc de `generation_config` e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função `forward` do modelo. Por exemplo, você pode definir o canvas inicial com `decoder_input_ids`.

**Retorna:** `torch.LongTensor` ou [DiffusionGemmaGenerationOutput](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput)

- `torch.LongTensor`: o texto gerado em ids.
- [DiffusionGemmaGenerationOutput](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationOutput): uma instância de `ModelOutput` contendo o texto gerado (`sequences`), bem como outras saídas opcionais.

Gera texto usando o modelo de difusão.

Ele contém um loop externo que realiza a geração autoregressiva de telas (blocos de tokens) e um loop

loop que realiza difusão em cada canvas. O algoritmo funciona aproximadamente da seguinte forma:
```
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
```

Exemplos:

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

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

**Parâmetros que controlam o comprimento da saída:**

max_new_tokens (`int`, *opcional*) : O número máximo de tokens a serem gerados, ignorando o número de tokens no prompt.

max_length (`int`, *opcional*) : O comprimento máximo da sequência de saída. `max_new_tokens` é recomendado para controlar quantos tokens o modelo gera.

**Parâmetros de difusão:**

max_denoising_steps (`int`) : O número máximo de etapas de desruidamento a serem executadas.

sampler_config (`EntropyBoundSamplerConfig`) : A configuração do sampler. Consulte [EntropyBoundSampler](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.EntropyBoundSampler) para entender como um sampler opera em um modelo de difusão de texto.

t_min (`float`) : A temperatura final no agendamento, ou seja, na última etapa de desruido. Consulte [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) para mais detalhes.

t_max (`float`) : A temperatura inicial no agendamento, ou seja, no primeiro passo de desruido. Consulte [LinearTemperatureScheduleLogitsProcessor](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.LinearTemperatureScheduleLogitsProcessor) para mais detalhes.

stability_threshold (`int`) : O número de etapas para as quais o canvas aceito deve ser o mesmo para acionar os critérios de parada. Consulte [StableAndConfidentStoppingCriteria](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) para mais detalhes.

confidence_threshold (`float`) : O limite para a média da entropia dos logits com escala de temperatura para acionar os critérios de parada. Consulte [StableAndConfidentStoppingCriteria](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.StableAndConfidentStoppingCriteria) para mais detalhes.

**Parâmetros que controlam o cache:**

cache_implementation (`str`, *opcional*) : Nome da classe de cache que será instanciada em `generate`, para decodificação mais rápida. Os valores possíveis são:  - `"dynamic"`: [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) - `"static"`: [StaticCache](/docs/transformers/main/pt/internal/generation_utils#transformers.StaticCache) - `"offloaded"`: `DynamicCache(offloaded=True)` - `"offloaded_static"`: `StaticCache(offloaded=True)` - `"quantized"`: [QuantizedCache](/docs/transformers/main/pt/internal/generation_utils#transformers.QuantizedCache)  Se nenhum for especificado, usaremos a cache padrão do modelo (que frequentemente é [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache)). Consulte nossa [documentação de cache](https://huggingface.co/docs/transformers/en/kv_cache) para mais informações.

cache_config (`dict`, *opcional*, padrão `None`) : Os argumentos usados na classe de cache de chave-valor podem ser passados em `cache_config`.

**Tokens especiais que podem ser usados no momento da geração:**

bos_token_id (`int`, *opcional*) : O id do token de *início de sequência*.

pad_token_id (`int`, *opcional*) : O id do token de *padding*.

eos_token_id (`Union[int, list[int]]`, *opcional*) : O id do token de *fim de sequência*. Opcionalmente, use uma lista para definir múltiplos tokens de *fim de sequência*.

Uma classe GenerationConfig com parametrização personalizada para [DiffusionGemmaGenerationMixin.generate()](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaGenerationMixin.generate).

## EntropyBoundSamplerConfig[[transformers.EntropyBoundSamplerConfig]]

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

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

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

**Parâmetros:**

entropy_bound (`float`) : O limite de entropia. Quanto maior esse valor, mais tokens serão aceitos. Consulte a docstring de [EntropyBoundSampler.accept_canvas()](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.EntropyBoundSampler.accept_canvas) para mais detalhes sobre como ele é aplicado.

Classe de configuração para o amostrador de limite de entropia.

## EntropyBoundSampler[[transformers.EntropyBoundSampler]]

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

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

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

**Parâmetros:**

config (`EntropyBoundSamplerConfig`) : A configuração do sampler.

canvas_length (`int`) : O comprimento do canvas.

vocab_size (`int`) : O tamanho do vocabulário.

max_denoising_steps (`int`) : O número máximo de etapas de desruidamento. (Não utilizado neste amostrador)

Classe de sampler que inicializa um canvas com tokens aleatórios, aceita tokens com base na entropia no nível de token e re-ruidos os tokens não aceitos.

Aqui está um esboço de como o loop do sampler funciona:
```
          +-----------------------+
          | 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)
```

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

**Parâmetros:**

current_canvas (`torch.LongTensor`) : O canvas atual.

denoiser_canvas (`torch.LongTensor`) : O canvas amostrado a partir das previsões do denoiser.

logits (`torch.Tensor`) : Os logits do denoiser.

cur_step (`int`) : O passo atual.

**Retorna:** `torch.LongTensor`

O canvas aceito.

Aceita tokens do denoiser com base em um limite de entropia. Mais concretamente, a amostragem prossegue aceitando k tokens com a menor entropia, de modo que

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

onde o lado esquerdo é o limite superior da informação mútua conjunta entre esses tokens, e, portanto, o amostrador escolhe k tokens que são aproximadamente independentes.

Originalmente proposto em https://arxiv.org/pdf/2505.24857

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

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

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

Inicializa e retorna um novo canvas de `canvas_length` tokens com valores aleatórios do vocabulário.

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

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

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

**Parâmetros:**

accepted_canvas (`torch.LongTensor`) : O canvas aceito.

cur_step (`int`) : O passo atual. (Não utilizado neste amostrador)

**Retorna:** `torch.LongTensor`

O canvas re-ruído.

Renoise todos os tokens não aceitos.

## StableAndConfidentStoppingCriteria[[transformers.StableAndConfidentStoppingCriteria]]

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

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

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

**Parâmetros:**

stability_threshold (`int`) : O número de etapas para as quais o canvas aceito deve ser o mesmo para acionar os critérios de parada.

confidence_threshold (`float`) : O limite para a média da entropia dos logits com escala de temperatura para acionar os critérios de parada.

Estratégia de parada adaptativa que interrompe quando o processo de difusão está confiante e estável. Mais especificamente:
- O processo de difusão é estável quando o canvas aceito é o mesmo ao longo de `stability_threshold` etapas.
- O processo de difusão é considerado confiável quando a média da entropia dos logits processados está abaixo de `confidence_threshold`.

## LinearTemperatureScheduleLogitsProcessor[[transformers.LinearTemperatureScheduleLogitsProcessor]]

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

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

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

**Parâmetros:**

t_min (`float`) : A temperatura final no agendamento, ou seja, na última etapa de desruido.

t_max (`float`) : A temperatura inicial no agendamento, ou seja, na primeira etapa de desruido.

max_denoising_steps (`int`) : O número máximo de etapas de desruido.

Processador de logits que aplica um agendamento linear de temperatura aos logits. Isso é semelhante ao `TemperatureLogitsWarper`, exceto que a temperatura é uma função do passo atual.

Na etapa n de N, a temperatura t é dada por t = t_min + ((t_max - t_min) * (n/N)).

## DiffusionGemmaPreTrainedModel[[transformers.DiffusionGemmaPreTrainedModel]]

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

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

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

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.

## DiffusionGemmaModel[[transformers.DiffusionGemmaModel]]

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

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

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

**Parâmetros:**

config ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Diffusion Gemma básico, que gera estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](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 não em cache para o prompt a ser codificado como contexto para o canvas.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)` ou `dict`, *opcional*) : Máscara para os tokens de entrada.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, canvas_length)`, *opcional*) : IDs de tokens para o canvas a ser refinado.

self_conditioning_logits (`torch.Tensor` de forma `(batch_size, canvas_length, vocab_size)`, *opcional*) : Logits de autocondicionamento da etapa anterior de desruido, usados para calcular os embeddings de autocondicionamento.

self_conditioning_mask (`torch.BoolTensor` de forma `(batch_size,)`, *opcional*) : Máscara por exemplo sobre `self_conditioning_logits`: exemplos definidos como `False` recebem um sinal de autocondicionamento zerado, como se nenhum logits tivesse sido passado para eles. Útil para treinamento, onde o autocondicionamento é habilitado por exemplo com alguma probabilidade.

decoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length+canvas_length)` ou `dict`, *opcional*) : Máscara de atenção para o cache KV do decodificador. Usada para especificar entradas do cache KV do codificador preenchidas com padding ou não populadas.

decoder_position_ids (`torch.LongTensor` de forma `(batch_size, canvas_length)`, *opcional*) : Os IDs de posição para os tokens no canvas.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** `DiffusionGemmaModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `DiffusionGemmaModelOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) e das entradas.

O método forward do [DiffusionGemmaModel](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do codificador. Definido apenas quando `input_ids` é fornecido, por exemplo, para calcular uma perda autoregressiva no codificador durante o treinamento.

## DiffusionGemmaEncoderModel[[transformers.DiffusionGemmaEncoderModel]]

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

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

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

**Parâmetros:**

config ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo de codificador DiffusionGemma, composto por um backbone de visão e um modelo de linguagem, *sem* uma cabeça de modelagem de linguagem. Ele é muito semelhante ao Gemma4Model, exceto que não suporta entradas de áudio ou vídeo e sempre assume o caminho de código MoE nas camadas internas.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

[Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando `image_processor_class`. Consulte `image_processor_class.__call__` para detalhes ([Gemma4Processor](/docs/transformers/main/pt/model_doc/gemma4#transformers.Gemma4Processor) usa `image_processor_class` para processar imagens).

attention_mask (`Union[torch.Tensor, dict]` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores da máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

mm_token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada correspondentes a cada modalidade. Por exemplo, texto (0), imagem (1), vídeo (2). Os ids de tipo de token multimodal podem ser obtidos usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de imagem, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) e das entradas.

O método forward do [DiffusionGemmaEncoderModel](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## DiffusionGemmaEncoderTextModel[[transformers.DiffusionGemmaEncoderTextModel]]

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

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

[Origem](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'>)
```

[Origem](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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`Union[torch.Tensor, dict]` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores da máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) e das entradas.

O método forward do [DiffusionGemmaEncoderTextModel](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaEncoderTextModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## DiffusionGemmaDecoderModel[[transformers.DiffusionGemmaDecoderModel]]

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

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

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

Modelo de decodificador para DiffusionGemma.

Processa tokens de canvas com autoatenção bidirecional e atenção cruzada ao cache KV do codificador. O decodificador lê, mas não atualiza o cache KV. Excluindo essas diferenças, é semelhante a `DiffusionGemmaEncoderTextModel`, e eles compartilham todos os pesos que têm em comum.

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

[Origem](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 dos tokens para o canvas a ser refinado.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

self_conditioning_logits (`torch.Tensor` de forma `(batch_size, canvas_length, vocab_size)`, *opcional*) : Logits de autocondicionamento da etapa anterior de desruido, usados para calcular os embeddings de autocondicionamento.

self_conditioning_mask (`torch.BoolTensor` de forma `(batch_size,)`, *opcional*) : Máscara por exemplo sobre `self_conditioning_logits`: exemplos definidos como `False` recebem um sinal de autocondicionamento zerado, como se nenhum logits tivesse sido passado para eles. Útil para treinamento, onde o autocondicionamento é habilitado por exemplo com alguma probabilidade.

decoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length+canvas_length)` ou `dict`, *opcional*) : Máscara de atenção para o cache KV do decodificador. Usada para especificar entradas do cache KV do codificador preenchidas com padding ou não populadas.

decoder_position_ids (`torch.LongTensor` de forma `(batch_size, canvas_length)`, *opcional*) : Os IDs de posição para os tokens no canvas.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) e das entradas.

O método forward do [DiffusionGemmaDecoderModel](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaDecoderModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## DiffusionGemmaForBlockDiffusion[[transformers.DiffusionGemmaForBlockDiffusion]]

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

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

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

Modelo DiffusionGemma para difusão em blocos. Ele chama `DiffusionGemmaModel` para obter os estados ocultos para o canvas de entrada, condicionados por um cache KV do prompt. Usando seu LM Head e seus blocos de autocondicionamento, ele converte esses estados ocultos em logits para amostrar o próximo canvas, bem como as embeddings de autocondicionamento para o próximo passo de difusão em blocos.

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

[Origem](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 não em cache para o prompt a ser codificado como contexto para o canvas.

attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)` ou `dict`, *opcional*) : Máscara para os tokens de entrada.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, canvas_length)`, *opcional*) : IDs de tokens para o canvas a ser refinado.

self_conditioning_logits (`torch.Tensor` de forma `(batch_size, canvas_length, vocab_size)`, *opcional*) : Logits de autocondicionamento da etapa anterior de desruido, usados para calcular os embeddings de autocondicionamento.

self_conditioning_mask (`torch.BoolTensor` de forma `(batch_size,)`, *opcional*) : Máscara por exemplo sobre `self_conditioning_logits`: exemplos definidos como `False` recebem um sinal de autocondicionamento zerado, como se nenhum logits tivesse sido passado para eles. Útil para treinamento, onde o autocondicionamento é habilitado por exemplo com alguma probabilidade.

decoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length+canvas_length)` ou `dict`, *opcional*) : Máscara de atenção para o cache KV do decodificador. Usada para especificar entradas do cache KV do codificador preenchidas com padding ou não populadas.

decoder_position_ids (`torch.LongTensor` de forma `(batch_size, canvas_length)`, *opcional*) : Os IDs de posição para os tokens no canvas.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** `DiffusionGemmaBlockDiffusionOutputWithPast` ou `tuple(torch.Tensor)`

Um `DiffusionGemmaBlockDiffusionOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DiffusionGemmaConfig](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaConfig)) e das entradas.

O método forward de [DiffusionGemmaForBlockDiffusion](/docs/transformers/main/pt/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*) -- Perda de modelagem de linguagem.
- **logits** (`torch.Tensor` de forma `(batch_size, canvas_length, config.text_config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do codificador. Definido apenas quando `input_ids` é fornecido, por exemplo, para calcular uma perda autoregressiva no codificador durante o treinamento.

Exemplo:

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