Hugging Face's logo

Transformers documentation

DiffusionGemma

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

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 2026-06-10.

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. Você pode encontrar um guia visual do modelo aqui.

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(). Se você estiver usando outro modelo do transformers em seu aplicativo, deve ser possível substituí-lo diretamente por este modelo.

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 para exemplos de uso e abra um issue 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

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

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.

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

DiffusionGemmaTextConfig

classe transformers.DiffusionGemmaTextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 262144hidden_size: int = 2304intermediate_size: int = 9216num_hidden_layers: int = 30num_attention_heads: int = 8num_key_value_heads: int = 4head_dim: int = 256hidden_activation: str = 'gelu_pytorch_tanh'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-06pad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1bos_token_id: int | None = 2tie_word_embeddings: bool = Truerope_parameters: dict | None = Noneattention_bias: bool = Falseattention_dropout: int | float | None = 0.0sliding_window: int = 512layer_types: list[str] | None = Noneuse_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = Nonenum_experts: int | None = Nonetop_k_experts: int | None = Nonemoe_intermediate_size: int | None = None )

Parâmetros

  • vocab_size (int, opcional, 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 grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. 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 utilizado.
  • 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) — Indica se deve ser usado 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 configuração.
  • use_bidirectional_attention (str, opcional) — Controla o comportamento da atenção bidirecional. Quando definido como "vision", os tokens de visão utilizam atenção bidirecional, enquanto os tokens de texto usam atenção causal. Quando definido como "all", todos os tokens utilizam 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

DiffusionGemmaConfig

classe transformers.DiffusionGemmaConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: transformers.models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig | dict[str, typing.Any] | None = Nonevision_config: transformers.configuration_utils.PreTrainedConfig | dict[str, typing.Any] | None = Noneboi_token_id: int | None = 255999eoi_token_id: int | None = 258882image_token_id: int | None = 258880initializer_range: float | None = 0.02tie_word_embeddings: bool = Truecanvas_length: int | None = 256 )

Parâmetros

  • text_config (Union[~models.diffusion_gemma.configuration_diffusion_gemma.DiffusionGemmaTextConfig, dict[str, Any]], opcional) — 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 configuração 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe transformers.DiffusionGemmaGenerationOutput

< >

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

Parâmetros

  • sequences (torch.LongTensor de forma (batch_size, sequence_length)) — 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 batch. 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

classe transformers.DiffusionGemmaGenerationMixin

< >

( )

Classe mixin para geração do DiffusionGemma. Contém todos os métodos em nível de modelo.

generate

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonestreamer: transformers.generation.streamers.BaseStreamer | None = Nonegeneration_config: transformers.models.diffusion_gemma.generation_diffusion_gemma.DiffusionGemmaGenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None**kwargs ) → torch.LongTensor or DiffusionGemmaGenerationOutput

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — A sequência usada como prompt para a geração.
  • past_key_values (Cache, opcional) — Objeto de 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 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 desruído serão enviados para lá.

Argumentos adicionais para usuários avançados

  • generation_config (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, os padrões do modelo serão carregados 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, 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, opcional) — 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

  • torch.LongTensor: o texto gerado em ids.
  • 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:

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

classe transformers.DiffusionGemmaGenerationConfig

< >

( **kwargs )

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 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 para mais detalhes.
  • t_max (float) — A temperatura inicial no agendamento, ou seja, no primeiro passo de desruido. Consulte 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. Veja StableAndConfidentStoppingCriteria para mais detalhes.
  • confidence_threshold (float) — O limiar para a média da entropia dos logits escalados por temperatura para acionar os critérios de parada. Veja 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:

    Se nenhum for especificado, usaremos o cache padrão do modelo (que frequentemente é DynamicCache). Consulte nossa documentação de 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().

EntropyBoundSamplerConfig

classe transformers.EntropyBoundSamplerConfig

< >

( entropy_bound: float )

Parâmetros

  • entropy_bound (float) — O limite de entropia. Quanto maior for esse valor, mais tokens serão aceitos. Consulte a docstring de EntropyBoundSampler.accept_canvas() para mais detalhes sobre como ele é aplicado.

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

EntropyBoundSampler

classe transformers.EntropyBoundSampler

< >

( config: EntropyBoundSamplerConfigcanvas_length: intvocab_size: intmax_denoising_steps: int )

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 desruido. (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

< >

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

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

< >

( batch_size: intdevice: device )

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

renoise_canvas

< >

( accepted_canvas: LongTensorcur_step: int ) → torch.LongTensor

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

classe transformers.StableAndConfidentStoppingCriteria

< >

( stability_threshold: intconfidence_threshold: float )

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 limiar para a média da entropia dos logits escalados por temperatura que aciona 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

classe transformers.LinearTemperatureScheduleLogitsProcessor

< >

( t_min: floatt_max: floatmax_denoising_steps: int )

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

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

classe transformers.DiffusionGemmaPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parâmetros

  • config (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() para carregar os pesos do modelo.

Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

( *args**kwargs )

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

DiffusionGemmaModel

classe transformers.DiffusionGemmaModel

< >

( config: DiffusionGemmaConfig )

Parâmetros

  • config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DiffusionGemmaModelOutputWithPast or tuple(torch.Tensor)

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) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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?

  • 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 desruidamento, 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 decoder. Usada para especificar entradas do cache KV do encoder que estão 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) e das entradas.

O método forward do 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) de 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 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 nos cabeçalhos 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

classe transformers.DiffusionGemmaEncoderModel

< >

( config: DiffusionGemmaConfig )

Parâmetros

  • config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonemm_token_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneimage_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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 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 de 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?

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

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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. Consulte 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 2D dos patches vindas 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 ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward do 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) de 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 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 nos cabeçalhos de autoatenção.

DiffusionGemmaEncoderTextModel

classe transformers.DiffusionGemmaEncoderTextModel

< >

( config: DiffusionGemmaTextConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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 de 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?

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

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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 ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward do 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) de 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 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 nos cabeçalhos de autoatenção.

DiffusionGemmaDecoderModel

classe transformers.DiffusionGemmaDecoderModel

< >

( config: DiffusionGemmaConfig )

Modelo de decodificador para DiffusionGemma.

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

forward

< >

( decoder_input_ids: LongTensorpast_key_values: transformers.cache_utils.Cache | None = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

Parâmetros

  • decoder_input_ids (torch.LongTensor de forma (batch_size, canvas_length)) — IDs de tokens para o canvas a ser refinado.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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 desruidamento, 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 decoder. Usada para especificar entradas do cache KV do encoder que estão 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 ou tuple(torch.Tensor)

Um 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) e das entradas.

O método forward do 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) de 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 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 nos cabeçalhos de autoatenção.

DiffusionGemmaForBlockDiffusion

classe transformers.DiffusionGemmaForBlockDiffusion

< >

( config: DiffusionGemmaConfig )

Modelo DiffusionGemma para difusão em blocos. Ele chama DiffusionGemmaModel para obter os estados ocultos do 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Noneself_conditioning_logits: typing.Optional[torch.Tensor] = Noneself_conditioning_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_attention_mask: typing.Union[torch.Tensor, dict, NoneType] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DiffusionGemmaBlockDiffusionOutputWithPast or tuple(torch.Tensor)

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) — Estados ocultos 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 no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a 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?

  • 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 desruidamento, 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 decoder. Usada para especificar entradas do cache KV do encoder que estão 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) e das entradas.

O método forward de 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    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) de 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 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 nos cabeçalhos 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:

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

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

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

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

←DePlot Donut→