Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /v0.43.0 /pt /api /pipelines /diffusion_gemma.md

mishig

2 days ago

preview code

download

raw

18.4 kB

# DiffusionGemma

DiffusionGemma é um modelo de linguagem encoder-decoder de difusão em blocos. Um encoder causal lê o prompt limpo (e quaisquer blocos gerados anteriormente) para um cache KV, e um decoder bidirecional remove o ruído de uma "tela" de tamanho fixo com `canvas_length` tokens, fazendo cross-attention para esse cache. A geração alterna um loop autoregressivo externo sobre as telas com um loop interno de remoção de ruído, em que cada etapa amostra tokens candidatos, confirma os mais confiantes via [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) em modo de corrupção uniforme e re-aplica ruído aos demais. O próprio modelo está em `transformers` como `DiffusionGemmaForBlockDiffusion`; o checkpoint publicado é [`google/diffusiongemma-26B-A4B-it`](https://huggingface.co/google/diffusiongemma-26B-A4B-it).

## Uso

```py
import torch
from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion
from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline
model_id = "google/diffusiongemma-26B-A4B-it"
model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
scheduler = BlockRefinementScheduler()
pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, mode="reduce-overhead", fullgraph=True)
output = pipe(
    prompt="Why is the sky blue?",
    gen_length=256,
    num_inference_steps=48,
    cache_implementation="static",
)
print(output.texts[0])
```

`num_inference_steps` é o número de etapas de remoção de ruído por canvas (48 corresponde ao checkpoint publicado); menos etapas são mais rápidas, mas de menor qualidade. `cache_implementation="static"` permite que o decodificador seja compilado com `torch.compile` usando cudagraphs (veja [Cache estático e compilação](#static-cache-and-compilation)); remova ambos para uma execução mais simples com cache dinâmico.

Para entradas de múltiplas rodadas ou multimodais, passe uma conversa bruta `messages` em vez de `prompt`. Trata-se de uma lista de dicts `{"role", "content"}` no formato de chat usual, que o processador executa por meio do seu modelo de chat:

```py
messages = [
    {"role": "user", "content": "Why is the sky blue?"},
]
# or with an image:
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Describe this image."},
        ],
    },
]
output = pipe(messages=messages, gen_length=256)
```

Para um turno de usuário único, você pode omitir `messages` e passar uma `image` junto com o `prompt`; o processador a converte automaticamente nos inputs de imagem do modelo.

## Agendadores

O scheduler é o sampler que remove o ruído de cada canvas e é intercambiável: troque-o para alterar a estratégia de amostragem sem tocar em mais nada. Três schedulers estão disponíveis:

- [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (padrão): confirma os tokens mais confiantes a cada etapa (acima de `threshold`, além de uma cota uniforme por etapa) e re-aplica ruído aos demais. `editing_threshold` permite, adicionalmente, reeditar tokens já confirmados.
- [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler): amostra cada posição da posterior discreta exata do processo de corrupção uniforme (D3PM). Ele é livre de parâmetros e o passo final compromete deterministicamente os tokens previstos.
- [EntropyBoundScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler): confirma as posições de menor entropia cuja entropia conjunta permanece abaixo de `entropy_bound`, de modo que tokens aproximadamente independentes sejam aceitos juntos. Ele anela sua temperatura de amostragem de `t_max` (`0.8`) no primeiro passo até `t_min` (`0.4`) no último, correspondendo ao amostrador do checkpoint liberado.

```py
from diffusers import DiscreteDDIMScheduler, EntropyBoundScheduler
pipe.scheduler = DiscreteDDIMScheduler()
# or: pipe.scheduler = EntropyBoundScheduler(entropy_bound=0.1)
output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
print(output.texts[0])
```

Os parâmetros de amostragem específicos do agendador (o `threshold`/`top_k` de refinamento de bloco, o limite de entropia, ...) são definidos na configuração do agendador:

```py
from diffusers import BlockRefinementScheduler
pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, threshold=0.9)
```

`EntropyBoundScheduler` reduz gradualmente a temperatura de amostragem (`t_max`/`t_min`) internamente ao longo das etapas de desnívelamento; `DiscreteDDIMScheduler` e `BlockRefinementScheduler` utilizam a `temperature` plana passada ao pipeline (`0.0` para guloso).

### Amostragem preditor-corretor

`DiscreteDDIMScheduler` suporta o preditor-corretor leave-one-out de [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765). Ele refina o canvas com `corrector_steps` varreduras de Gibbs que reamostram as posições de menor confiança a partir da condicional de uma coordenada da marginal ruidosa, o que mantém essa marginal invariante e melhora a geração sem custo adicional de treinamento. Ele funciona diretamente no checkpoint liberado: para difusão uniforme, o denoiser e a posterior leave-one-out são intercambiáveis em forma fechada, de modo que o corretor recupera as quantidades leave-one-out de que precisa sem qualquer re-treinamento.

As varreduras do corretor são incorporadas ao orçamento de `num_inference_steps` em vez de serem adicionadas por cima: o pipeline executa menos etapas do preditor e gasta os forwards liberados nos corretores, de modo que o número total de forwards do modelo permanece `num_inference_steps` e o custo do preditor-corretor é o mesmo que o da amostragem ancestral simples.

```py
from diffusers import DiscreteDDIMScheduler
pipe.scheduler = DiscreteDDIMScheduler(corrector_steps=2, corrector_k=12)
output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
print(output.texts[0])
```

## Adaptadores PEFT

O denoiser é um modelo do 🤗 Transformers, portanto os adaptadores são carregados por meio da sua integração nativa [PEFT](https://huggingface.co/docs/peft), em vez da API `load_lora_weights` do diffusers. Como essa integração é agnóstica em relação ao tipo de adaptador, as mesmas chamadas carregam LoRA, DoRA ou qualquer outro adaptador PEFT (por exemplo, a saída do `SFTTrainer` do TRL). Gerencie os adaptadores diretamente no componente do modelo:

```py
pipe.model.load_adapter("path/to/adapter", adapter_name="sft")  # LoRA, DoRA, ...
pipe.model.set_adapter("sft")
output = pipe(prompt="Why is the sky blue?", gen_length=256)
pipe.model.disable_adapters()  # run the base model
pipe.model.delete_adapter("sft")
```

Os adaptadores permanecem ativos e não mesclados: o DiffusionGemma vincula os pesos base do codificador e do decodificador, portanto, fundir um adaptador neles corromperia ambos os ramos.

## Cache estático e compilação

O pipeline pré-preenche o codificador uma vez por bloco em um cache reutilizável (um `DynamicCache` por padrão). Passar `cache_implementation="static"` usa um `StaticCache` de forma fixa em vez disso, cujas formas permitem `torch.compile` o decodificador com cudagraphs para um aumento adicional de velocidade (o pipeline marca cada etapa e clona os logits para que a memória dos cudagraphs não seja sobrescrita); este é o setup mostrado em [Uso](#usage). Remova tanto a chamada `torch.compile` quanto `cache_implementation="static"` para uma execução mais simples com cache dinâmico.

## Parada adaptativa

Um bloco geralmente converge antes que todos os `num_inference_steps` sejam utilizados, portanto, por padrão, o pipeline congela cada exemplo do lote assim que sua previsão de argmax se torna estável por `stability_threshold` passos e sua entropia média por token fica abaixo de `confidence_threshold` (`0.005`, o valor usado pelo checkpoint liberado). O loop de desruidamento termina quando todos os exemplos são congelados. Isso reduz aproximadamente pela metade o número de forwards do decodificador com qualidade equivalente e é o principal fator de aumento de throughput. Passe `confidence_threshold=None` para sempre executar todos os `num_inference_steps`:

```py
output = pipe(prompt="Why is the sky blue?", gen_length=256, confidence_threshold=None)  # disable adaptive stopping
```

## Callbacks

Os callbacks são executados após cada etapa de remoção de ruído. Passe `callback_on_step_end_tensor_inputs` para selecionar quais tensores são incluídos em `callback_kwargs`; `canvas` (os tokens do bloco atual) e `logits` estão disponíveis. Retorne `{"canvas": ...}` do callback para substituir o canvas.

```py
def on_step_end(pipe, step, timestep, callback_kwargs):
    canvas = callback_kwargs["canvas"]
    # Inspect or modify `canvas` here.
    return {"canvas": canvas}
out = pipe(
    prompt="Why is the sky blue?",
    callback_on_step_end=on_step_end,
    callback_on_step_end_tensor_inputs=["canvas"],
)
```

## DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

#### diffusers.DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

```python
diffusers.DiffusionGemmaPipeline(model: Any, scheduler: BlockRefinementScheduler | DiscreteDDIMScheduler | EntropyBoundScheduler, processor: Any)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L53)

**Parâmetros:**

model ([DiffusionGemmaForBlockDiffusion](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion)) : O desruidor de difusão por blocos (codificador causal + decodificador bidirecional com pesos compartilhados).

scheduler ([BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler), [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler) ou [EntropyBoundScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler)) : O sampler que confirma e re-ruidifica os tokens do canvas a cada etapa de desruidificação.

processor ([ProcessorMixin](https://huggingface.co/docs/transformers/v5.22.2/en/main_classes/processors#transformers.ProcessorMixin)) : o processador usado para aplicar o modelo de chat e decodificar os tokens gerados.

Pipeline para geração de texto por difusão em blocos do DiffusionGemma.

DiffusionGemma é um modelo encoder-decoder de difusão por blocos: um encoder causal lê o prompt limpo (e quaisquer blocos gerados anteriormente) para um cache KV, e um decoder bidirecional remove o ruído de uma "tela" de tamanho fixo com `canvas_length` tokens, fazendo cross-attention para esse cache. A geração alterna um loop autoregressivo externo sobre as telas com um loop interno de remoção de ruído, em que cada etapa amostra tokens candidatos, confirma os mais confiantes via [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (modo de corrupção uniforme, `mask_token_id=None`) e re-aplica ruído aos demais.

O modelo deve ser uma instância de `DiffusionGemmaForBlockDiffusion` que exponha `forward(input_ids, decoder_input_ids=..., self_conditioning_logits=..., ...)` e retorne logits com a forma `[batch, canvas_length, vocab_size]` sobre o canvas. Consulte o cartão do modelo em https://huggingface.co/google/diffusiongemma-26B-A4B-it.

#### __call__[[diffusers.DiffusionGemmaPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, messages: list[dict] | None = None, image: Any | list[Any] | None = None, add_generation_prompt: bool = True, gen_length: int = 256, num_inference_steps: int = 48, temperature: float = 0.0, cache_implementation: str | None = None, eos_early_stop: bool = True, eos_token_id: int | None = None, stability_threshold: int = 1, confidence_threshold: float | None = 0.005, generator: torch.Generator | None = None, output_type: str = 'text', return_dict: bool = True, callback_on_step_end: Callable[[Any, int, int, dict], dict] | PipelineCallback | MultiPipelineCallbacks | None = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L163)

**Parâmetros:**

prompt (`str` ou `List[str]`, *opcional*) : Texto do prompt, envolvido em um modelo de chat e tokenizado pelo processador. Forneça este ou `messages`.

messages (`List[Dict]`, *opcional*) : Uma conversa de chat bruta para codificar, por exemplo, `[{"role": "user", "content": "Hello"}]` ou uma conversa multimodal de múltiplas rodadas. Use isso em vez de `prompt` para qualquer coisa além de uma única rodada do usuário.

image (`PIL.Image.Image` ou `List`, *opcional*) : Imagem(ns) para combinar com `prompt` para geração multimodal; o processador as converte nas entradas de imagem do modelo. Para layouts mais ricos, coloque o conteúdo da imagem diretamente em `messages`.

add_generation_prompt (`bool`, padrão `True`) : Se deve adicionar o prompt de geração ao aplicar o modelo de chat.

gen_length (`int`, padrão `256`) : Número de tokens a serem gerados, arredondado para cima até um múltiplo do `canvas_length` do modelo.

num_inference_steps (`int`, padrão `48`) : Número de etapas de desruidamento por canvas.

temperature (`float`, padrão `0.0`) : Temperatura de amostragem para `DiscreteDDIMScheduler`/`BlockRefinementScheduler` (`0.0` é guloso); `EntropyBoundScheduler` ignora esse parâmetro e ajusta a própria temperatura. Outros parâmetros de amostragem (por exemplo, `top_k`, `threshold`, `t_min`/`t_max`) fazem parte da configuração do agendador; defina-os no agendador, por exemplo, `pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, top_k=...)`.

cache_implementation (`str`, *opcional*) : Defina como `"static"` para pré-preencher o codificador uma vez por bloco em um `StaticCache` persistente e executar o decodificador contra ele com formas fixas, em vez de re-codificar a sequência completa a cada etapa. As formas fixas também permitem compilar o decodificador, por exemplo, `pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, fullgraph=True)`.
eos_early_stop (`bool`, padrão `True`) : Se deve parar de gerar mais telas assim que todas as sequências emitirem EOS.
eos_token_id (`int`, *opcional*) : ID do token EOS para parada antecipada. Usa o tokenizer do processador como alternativa.
stability_threshold (`int`, padrão `1`) : Número de passos consecutivos em que a previsão argmax de um exemplo deve permanecer inalterada para que esse exemplo seja considerado estável. Usado apenas quando `confidence_threshold` está definido.

confidence_threshold (`float`, *opcional*, padrão `0.005`) : Congela cada exemplo assim que ele se torna estável (veja `stability_threshold`) e a entropia média por token dos logits de previsão com formato de agendador fica abaixo desse valor. O loop de desruidamento do bloco termina quando todos os exemplos são congelados. Acelera a geração com qualidade equivalente; o padrão corresponde ao checkpoint liberado. Defina como `None` para sempre executar todos os `num_inference_steps`.

generator (`torch.Generator`, *opcional*) : RNG para amostragem.

output_type (`str`, padrão `"text"`) : `"text"` decodifica sequências em strings (requer um processador); `"seq"` retorna apenas IDs de tokens.
return_dict (`bool`, padrão `True`) : Se deve retornar um [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) em vez de uma tupla.

callback_on_step_end (`Callable` ou `PipelineCallback`, *opcional*) : Callback executado após cada etapa de remoção de ruído com a assinatura `callback_on_step_end(self, step, timestep, callback_kwargs)`. Chaves de tensor permitidas: `canvas`, `logits`.
callback_on_step_end_tensor_inputs (`List[str]`, *opcional*) : Chaves de tensor para passar ao callback.

**Retorna:** [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) ou `tuple`

Os IDs dos tokens gerados (`sequences`) e, para `output_type="text"`, os `texts` decodificados.

Gere texto com difusão em blocos.

Exemplos:
```python
>>> import torch
>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion
>>> from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline
>>> model_id = "google/diffusiongemma-26B-A4B-it"
>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> scheduler = BlockRefinementScheduler()
>>> pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
>>> output = pipe(prompt="Why is the sky blue?", gen_length=256)
>>> print(output.texts[0])
```

## DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

#### diffusers.DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

```python
diffusers.DiffusionGemmaPipelineOutput(sequences: torch.LongTensor, texts: list[str] | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_output.py#L25)

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size, gen_length)`) : Os IDs dos tokens gerados (o prompt é removido).

texts (`list[str]`, *opcional*) : O texto decodificado, uma string por sequência. Definido apenas para `output_type="text"`.

Classe de saída para geração por difusão em blocos do DiffusionGemma.

Xet Storage Details

Size:: 18.4 kB
Xet hash:: 80a7d4756605087af451bbce7eb9c8012464f3f71356c7ddd61aa779f1637f02

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# DiffusionGemma

	DiffusionGemma é um modelo de linguagem encoder-decoder de difusão em blocos. Um encoder causal lê o prompt limpo (e quaisquer blocos gerados anteriormente) para um cache KV, e um decoder bidirecional remove o ruído de uma "tela" de tamanho fixo com `canvas_length` tokens, fazendo cross-attention para esse cache. A geração alterna um loop autoregressivo externo sobre as telas com um loop interno de remoção de ruído, em que cada etapa amostra tokens candidatos, confirma os mais confiantes via [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) em modo de corrupção uniforme e re-aplica ruído aos demais. O próprio modelo está em `transformers` como `DiffusionGemmaForBlockDiffusion`; o checkpoint publicado é [`google/diffusiongemma-26B-A4B-it`](https://huggingface.co/google/diffusiongemma-26B-A4B-it).

	## Uso

	```py
	import torch
	from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion

	from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline

	model_id = "google/diffusiongemma-26B-A4B-it"
	model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
	processor = AutoProcessor.from_pretrained(model_id)
	scheduler = BlockRefinementScheduler()

	pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
	pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, mode="reduce-overhead", fullgraph=True)
	output = pipe(
	prompt="Why is the sky blue?",
	gen_length=256,
	num_inference_steps=48,
	cache_implementation="static",
	)
	print(output.texts[0])
	```

	`num_inference_steps` é o número de etapas de remoção de ruído por canvas (48 corresponde ao checkpoint publicado); menos etapas são mais rápidas, mas de menor qualidade. `cache_implementation="static"` permite que o decodificador seja compilado com `torch.compile` usando cudagraphs (veja [Cache estático e compilação](#static-cache-and-compilation)); remova ambos para uma execução mais simples com cache dinâmico.

	Para entradas de múltiplas rodadas ou multimodais, passe uma conversa bruta `messages` em vez de `prompt`. Trata-se de uma lista de dicts `{"role", "content"}` no formato de chat usual, que o processador executa por meio do seu modelo de chat:

	```py
	messages = [
	{"role": "user", "content": "Why is the sky blue?"},
	]
	# or with an image:
	messages = [
	{
	"role": "user",
	"content": [
	{"type": "image", "image": image},
	{"type": "text", "text": "Describe this image."},
	],
	},
	]
	output = pipe(messages=messages, gen_length=256)
	```

	Para um turno de usuário único, você pode omitir `messages` e passar uma `image` junto com o `prompt`; o processador a converte automaticamente nos inputs de imagem do modelo.

	## Agendadores

	O scheduler é o sampler que remove o ruído de cada canvas e é intercambiável: troque-o para alterar a estratégia de amostragem sem tocar em mais nada. Três schedulers estão disponíveis:

	- [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (padrão): confirma os tokens mais confiantes a cada etapa (acima de `threshold`, além de uma cota uniforme por etapa) e re-aplica ruído aos demais. `editing_threshold` permite, adicionalmente, reeditar tokens já confirmados.
	- [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler): amostra cada posição da posterior discreta exata do processo de corrupção uniforme (D3PM). Ele é livre de parâmetros e o passo final compromete deterministicamente os tokens previstos.
	- [EntropyBoundScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler): confirma as posições de menor entropia cuja entropia conjunta permanece abaixo de `entropy_bound`, de modo que tokens aproximadamente independentes sejam aceitos juntos. Ele anela sua temperatura de amostragem de `t_max` (`0.8`) no primeiro passo até `t_min` (`0.4`) no último, correspondendo ao amostrador do checkpoint liberado.

	```py
	from diffusers import DiscreteDDIMScheduler, EntropyBoundScheduler

	pipe.scheduler = DiscreteDDIMScheduler()
	# or: pipe.scheduler = EntropyBoundScheduler(entropy_bound=0.1)
	output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
	print(output.texts[0])
	```

	Os parâmetros de amostragem específicos do agendador (o `threshold`/`top_k` de refinamento de bloco, o limite de entropia, ...) são definidos na configuração do agendador:

	```py
	from diffusers import BlockRefinementScheduler

	pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, threshold=0.9)
	```

	`EntropyBoundScheduler` reduz gradualmente a temperatura de amostragem (`t_max`/`t_min`) internamente ao longo das etapas de desnívelamento; `DiscreteDDIMScheduler` e `BlockRefinementScheduler` utilizam a `temperature` plana passada ao pipeline (`0.0` para guloso).

	### Amostragem preditor-corretor

	`DiscreteDDIMScheduler` suporta o preditor-corretor leave-one-out de [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765). Ele refina o canvas com `corrector_steps` varreduras de Gibbs que reamostram as posições de menor confiança a partir da condicional de uma coordenada da marginal ruidosa, o que mantém essa marginal invariante e melhora a geração sem custo adicional de treinamento. Ele funciona diretamente no checkpoint liberado: para difusão uniforme, o denoiser e a posterior leave-one-out são intercambiáveis em forma fechada, de modo que o corretor recupera as quantidades leave-one-out de que precisa sem qualquer re-treinamento.

	As varreduras do corretor são incorporadas ao orçamento de `num_inference_steps` em vez de serem adicionadas por cima: o pipeline executa menos etapas do preditor e gasta os forwards liberados nos corretores, de modo que o número total de forwards do modelo permanece `num_inference_steps` e o custo do preditor-corretor é o mesmo que o da amostragem ancestral simples.

	```py
	from diffusers import DiscreteDDIMScheduler

	pipe.scheduler = DiscreteDDIMScheduler(corrector_steps=2, corrector_k=12)
	output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
	print(output.texts[0])
	```

	## Adaptadores PEFT

	O denoiser é um modelo do 🤗 Transformers, portanto os adaptadores são carregados por meio da sua integração nativa [PEFT](https://huggingface.co/docs/peft), em vez da API `load_lora_weights` do diffusers. Como essa integração é agnóstica em relação ao tipo de adaptador, as mesmas chamadas carregam LoRA, DoRA ou qualquer outro adaptador PEFT (por exemplo, a saída do `SFTTrainer` do TRL). Gerencie os adaptadores diretamente no componente do modelo:

	```py
	pipe.model.load_adapter("path/to/adapter", adapter_name="sft") # LoRA, DoRA, ...
	pipe.model.set_adapter("sft")
	output = pipe(prompt="Why is the sky blue?", gen_length=256)

	pipe.model.disable_adapters() # run the base model
	pipe.model.delete_adapter("sft")
	```

	Os adaptadores permanecem ativos e não mesclados: o DiffusionGemma vincula os pesos base do codificador e do decodificador, portanto, fundir um adaptador neles corromperia ambos os ramos.

	## Cache estático e compilação

	O pipeline pré-preenche o codificador uma vez por bloco em um cache reutilizável (um `DynamicCache` por padrão). Passar `cache_implementation="static"` usa um `StaticCache` de forma fixa em vez disso, cujas formas permitem `torch.compile` o decodificador com cudagraphs para um aumento adicional de velocidade (o pipeline marca cada etapa e clona os logits para que a memória dos cudagraphs não seja sobrescrita); este é o setup mostrado em [Uso](#usage). Remova tanto a chamada `torch.compile` quanto `cache_implementation="static"` para uma execução mais simples com cache dinâmico.

	## Parada adaptativa

	Um bloco geralmente converge antes que todos os `num_inference_steps` sejam utilizados, portanto, por padrão, o pipeline congela cada exemplo do lote assim que sua previsão de argmax se torna estável por `stability_threshold` passos e sua entropia média por token fica abaixo de `confidence_threshold` (`0.005`, o valor usado pelo checkpoint liberado). O loop de desruidamento termina quando todos os exemplos são congelados. Isso reduz aproximadamente pela metade o número de forwards do decodificador com qualidade equivalente e é o principal fator de aumento de throughput. Passe `confidence_threshold=None` para sempre executar todos os `num_inference_steps`:

	```py
	output = pipe(prompt="Why is the sky blue?", gen_length=256, confidence_threshold=None) # disable adaptive stopping
	```

	## Callbacks

	Os callbacks são executados após cada etapa de remoção de ruído. Passe `callback_on_step_end_tensor_inputs` para selecionar quais tensores são incluídos em `callback_kwargs`; `canvas` (os tokens do bloco atual) e `logits` estão disponíveis. Retorne `{"canvas": ...}` do callback para substituir o canvas.

	```py
	def on_step_end(pipe, step, timestep, callback_kwargs):
	canvas = callback_kwargs["canvas"]
	# Inspect or modify `canvas` here.
	return {"canvas": canvas}

	out = pipe(
	prompt="Why is the sky blue?",
	callback_on_step_end=on_step_end,
	callback_on_step_end_tensor_inputs=["canvas"],
	)
	```

	## DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

	#### diffusers.DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

	```python
	diffusers.DiffusionGemmaPipeline(model: Any, scheduler: BlockRefinementScheduler \| DiscreteDDIMScheduler \| EntropyBoundScheduler, processor: Any)
	```

	[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L53)

	Parâmetros:

	model ([DiffusionGemmaForBlockDiffusion](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion)) : O desruidor de difusão por blocos (codificador causal + decodificador bidirecional com pesos compartilhados).

	scheduler ([BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler), [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler) ou [EntropyBoundScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler)) : O sampler que confirma e re-ruidifica os tokens do canvas a cada etapa de desruidificação.

	processor ([ProcessorMixin](https://huggingface.co/docs/transformers/v5.22.2/en/main_classes/processors#transformers.ProcessorMixin)) : o processador usado para aplicar o modelo de chat e decodificar os tokens gerados.

	Pipeline para geração de texto por difusão em blocos do DiffusionGemma.

	DiffusionGemma é um modelo encoder-decoder de difusão por blocos: um encoder causal lê o prompt limpo (e quaisquer blocos gerados anteriormente) para um cache KV, e um decoder bidirecional remove o ruído de uma "tela" de tamanho fixo com `canvas_length` tokens, fazendo cross-attention para esse cache. A geração alterna um loop autoregressivo externo sobre as telas com um loop interno de remoção de ruído, em que cada etapa amostra tokens candidatos, confirma os mais confiantes via [BlockRefinementScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (modo de corrupção uniforme, `mask_token_id=None`) e re-aplica ruído aos demais.

	O modelo deve ser uma instância de `DiffusionGemmaForBlockDiffusion` que exponha `forward(input_ids, decoder_input_ids=..., self_conditioning_logits=..., ...)` e retorne logits com a forma `[batch, canvas_length, vocab_size]` sobre o canvas. Consulte o cartão do modelo em https://huggingface.co/google/diffusiongemma-26B-A4B-it.

	#### __call__[[diffusers.DiffusionGemmaPipeline.__call__]]

	```python
	__call__(prompt: str \| list[str] \| None = None, messages: list[dict] \| None = None, image: Any \| list[Any] \| None = None, add_generation_prompt: bool = True, gen_length: int = 256, num_inference_steps: int = 48, temperature: float = 0.0, cache_implementation: str \| None = None, eos_early_stop: bool = True, eos_token_id: int \| None = None, stability_threshold: int = 1, confidence_threshold: float \| None = 0.005, generator: torch.Generator \| None = None, output_type: str = 'text', return_dict: bool = True, callback_on_step_end: Callable[[Any, int, int, dict], dict] \| PipelineCallback \| MultiPipelineCallbacks \| None = None, callback_on_step_end_tensor_inputs: list[str] \| None = None)
	```

	[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L163)

	Parâmetros:

	prompt (`str` ou `List[str]`, opcional) : Texto do prompt, envolvido em um modelo de chat e tokenizado pelo processador. Forneça este ou `messages`.

	messages (`List[Dict]`, opcional) : Uma conversa de chat bruta para codificar, por exemplo, `[{"role": "user", "content": "Hello"}]` ou uma conversa multimodal de múltiplas rodadas. Use isso em vez de `prompt` para qualquer coisa além de uma única rodada do usuário.

	image (`PIL.Image.Image` ou `List`, opcional) : Imagem(ns) para combinar com `prompt` para geração multimodal; o processador as converte nas entradas de imagem do modelo. Para layouts mais ricos, coloque o conteúdo da imagem diretamente em `messages`.

	add_generation_prompt (`bool`, padrão `True`) : Se deve adicionar o prompt de geração ao aplicar o modelo de chat.

	gen_length (`int`, padrão `256`) : Número de tokens a serem gerados, arredondado para cima até um múltiplo do `canvas_length` do modelo.

	num_inference_steps (`int`, padrão `48`) : Número de etapas de desruidamento por canvas.

	temperature (`float`, padrão `0.0`) : Temperatura de amostragem para `DiscreteDDIMScheduler`/`BlockRefinementScheduler` (`0.0` é guloso); `EntropyBoundScheduler` ignora esse parâmetro e ajusta a própria temperatura. Outros parâmetros de amostragem (por exemplo, `top_k`, `threshold`, `t_min`/`t_max`) fazem parte da configuração do agendador; defina-os no agendador, por exemplo, `pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, top_k=...)`.

	cache_implementation (`str`, opcional) : Defina como `"static"` para pré-preencher o codificador uma vez por bloco em um `StaticCache` persistente e executar o decodificador contra ele com formas fixas, em vez de re-codificar a sequência completa a cada etapa. As formas fixas também permitem compilar o decodificador, por exemplo, `pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, fullgraph=True)`.

	eos_early_stop (`bool`, padrão `True`) : Se deve parar de gerar mais telas assim que todas as sequências emitirem EOS.

	eos_token_id (`int`, opcional) : ID do token EOS para parada antecipada. Usa o tokenizer do processador como alternativa.

	stability_threshold (`int`, padrão `1`) : Número de passos consecutivos em que a previsão argmax de um exemplo deve permanecer inalterada para que esse exemplo seja considerado estável. Usado apenas quando `confidence_threshold` está definido.

	confidence_threshold (`float`, opcional, padrão `0.005`) : Congela cada exemplo assim que ele se torna estável (veja `stability_threshold`) e a entropia média por token dos logits de previsão com formato de agendador fica abaixo desse valor. O loop de desruidamento do bloco termina quando todos os exemplos são congelados. Acelera a geração com qualidade equivalente; o padrão corresponde ao checkpoint liberado. Defina como `None` para sempre executar todos os `num_inference_steps`.

	generator (`torch.Generator`, opcional) : RNG para amostragem.

	output_type (`str`, padrão `"text"`) : `"text"` decodifica sequências em strings (requer um processador); `"seq"` retorna apenas IDs de tokens.

	return_dict (`bool`, padrão `True`) : Se deve retornar um [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) em vez de uma tupla.

	callback_on_step_end (`Callable` ou `PipelineCallback`, opcional) : Callback executado após cada etapa de remoção de ruído com a assinatura `callback_on_step_end(self, step, timestep, callback_kwargs)`. Chaves de tensor permitidas: `canvas`, `logits`.

	callback_on_step_end_tensor_inputs (`List[str]`, opcional) : Chaves de tensor para passar ao callback.

	Retorna: [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) ou `tuple`

	Os IDs dos tokens gerados (`sequences`) e, para `output_type="text"`, os `texts` decodificados.

	Gere texto com difusão em blocos.

	Exemplos:
	```python
	>>> import torch
	>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion
	>>> from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline

	>>> model_id = "google/diffusiongemma-26B-A4B-it"
	>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
	>>> processor = AutoProcessor.from_pretrained(model_id)
	>>> scheduler = BlockRefinementScheduler()

	>>> pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
	>>> output = pipe(prompt="Why is the sky blue?", gen_length=256)
	>>> print(output.texts[0])
	```

	## DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

	#### diffusers.DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

	```python
	diffusers.DiffusionGemmaPipelineOutput(sequences: torch.LongTensor, texts: list[str] \| None = None)
	```

	[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_output.py#L25)

	Parâmetros:

	sequences (`torch.LongTensor` de forma `(batch_size, gen_length)`) : Os IDs dos tokens gerados (o prompt é removido).

	texts (`list[str]`, opcional) : O texto decodificado, uma string por sequência. Definido apenas para `output_type="text"`.

	Classe de saída para geração por difusão em blocos do DiffusionGemma.