Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 2026-08-09.

MuseGlimmerAssistant

MuseGlimmerAssistant é o DFlash drafter para MuseGlimmer. Não é um modelo de linguagem autônomo. Ele possui 5 camadas de janela deslizante e não tem embeddings próprios. Ele utiliza os embeddings de entrada e saída do modelo principal e lê os estados ocultos do modelo principal em target_layer_ids (camadas 1, 13, 25, 37 e 49 por padrão) como contexto.

Em vez de gerar um token de cada vez, o modelo rascunhador remove o ruído de um bloco inteiro de block_size tokens mascarados em uma única passagem de frente, como uma janela de difusão. Em seguida, o modelo principal verifica o bloco em uma única etapa. A Meta relata decodificação 3,1x mais rápida em uma RTX 5090 e 1,5-1,8x em chips Apple M-series.

Passe o drafter para generate() como assistant_model e defina speculation_type="dflash". O drafter deve ser carregado no mesmo dtype e no mesmo dispositivo que o modelo principal.

from transformers import AutoProcessor, MuseGlimmerAssistantModel, MuseGlimmerForConditionalGeneration

processor = AutoProcessor.from_pretrained("meta-models/Muse-Glimmer-30B")
model = MuseGlimmerForConditionalGeneration.from_pretrained(
    "meta-models/Muse-Glimmer-30B",
    device_map="auto",
)
drafter = MuseGlimmerAssistantModel.from_pretrained(
    "meta-models/Muse-Glimmer-30B-assistant",
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": [{"type": "text", "text": "Write a bash one-liner that counts lines of Python in a repo."}],
    },
]
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(
    **inputs,
    assistant_model=drafter,
    speculation_type="dflash",
    max_new_tokens=256,
)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

Observações

O drafter precisa dos estados ocultos do modelo principal, portanto generate força output_hidden_states=True para o modelo de destino quando speculation_type="dflash".
Veja o post no blog A Meta está de volta com o Muse Glimmer: local, agêntico, multimodal e de código aberto! para mais detalhes e exemplos de uso.

MuseGlimmerAssistantConfig

classe transformers.MuseGlimmerAssistantConfig

< source >

( 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 = Nonehidden_size: int = 6656intermediate_size: int = 19968num_hidden_layers: int = 5num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int = 128rms_norm_eps: float = 1e-05rope_parameters: dict | None = Nonemax_position_embeddings: int = 131072sliding_window: int = 2048layer_types: list[str] | None = Noneattention_dropout: float | int = 0hidden_act: str = 'silu'bos_token_id: int | None = 200000eos_token_id: int | None = 200001pad_token_id: int | None = 200018block_size: int = 16mask_token_id: int = 201818target_layer_ids: list[int] | None = None )

Parâmetros

hidden_size (int, opcional, padrão 6656) — Dimensão das representações ocultas.
intermediate_size (int, opcional, padrão 19968) — Dimensão das representações do MLP.
num_hidden_layers (int, opcional, padrão 5) — Número de camadas ocultas no decodificador do Transformer.
num_attention_heads (int, opcional, padrão 32) — 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 8) — 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 128) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
rms_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização rms.
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.
max_position_embeddings (int, opcional, padrão 131072) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
sliding_window (int, opcional, padrão 2048) — 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.
attention_dropout (Union[float, int], opcional, padrão 0) — A taxa de dropout para as probabilidades de atenção.
hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
bos_token_id (int, opcional, padrão 200000) — ID do token usado para o início do fluxo no vocabulário.
eos_token_id (int, opcional, padrão 200001) — ID do token usado para o fim do fluxo no vocabulário.
pad_token_id (int, opcional, padrão 200018) — ID do token usado para preenchimento no vocabulário.
block_size (int, opcional) — O tamanho do bloco das entradas de ruído que serão desruinizadas.
mask_token_id (int, opcional) — IDs de tokens de máscara usados como entrada ruidosa para o modelo.
target_layer_ids (list[int], opcional) — IDs de camadas com índice zero cujos estados ocultos são concatenados como contexto para o modelo.

Esta é a classe de configuração para armazenar a configuração de um MuseGlimmerAssistantModel. Ela é usada para instanciar um modelo Muse Glimmer Assistant 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 meta-models/Muse-Glimmer-30B-assistant

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 MuseGlimmerAssistantConfig, MuseGlimmerAssistantModel

>>> # Initializing a Muse Glimmer Assistant config similar to `meta-models/Muse-Glimmer-30B-assistant`.
>>> configuration = MuseGlimmerAssistantConfig(text_config)

>>> # Initializing a model from the `meta-models/Muse-Glimmer-30B-assistant` configuration.
>>> model = MuseGlimmerAssistantModel(configuration)

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

MuseGlimmerAssistantPreTrainedModel

classe transformers.MuseGlimmerAssistantPreTrainedModel

< source >

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

MuseGlimmerAssistantModel

classe transformers.MuseGlimmerAssistantModel

< source >

( config: MuseGlimmerAssistantConfig )

Parâmetros

config (MuseGlimmerAssistantConfig) — 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 básico Muse Glimmer Assistant, que gera estados ocultos brutos sem nenhum head específico no topo.

forward

< source >

( noise_embeds: FloatTensorcontext_hidden_states: FloatTensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.DFlashCache | None = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.FloatTensor)

Parâmetros

noise_embeds (torch.FloatTensor de forma [batch_size, config.block_size, dim]) — Embedding de entrada para o último token âncora gerado e para os tokens de máscara a serem desruídos.
context_hidden_states (torch.FloatTensor de forma [batch_size, number_of_previous_accepted_tokens, dim * len(config.target_layer_ids)]) — Estados ocultos de contexto das camadas selecionadas do modelo de destino, concatenados na última dimensão.
attention_mask (torch.Tensor de forma [batch_size, number_of_previous_accepted_tokens + config.block_size]) — Semelhante ao attention_mask usual, mas observe que ele tem comprimento number_of_previous_accepted_tokens + config.block_size, porque a Attention primeiro concatenará context_hidden_states e os hidden states derivados de noise_embeds, de modo que os estados k/v não terão o mesmo comprimento que os q_states, mesmo antes da chamada cache.update(). Assim, a dimensão kv_seq_len da máscara de atenção precisa abranger as posições adicionais.
position_ids (torch.Tensor de forma [batch_size, number_of_previous_accepted_tokens + config.block_size]) — Semelhante aos position_ids usuais, mas observe que ele tem comprimento number_of_previous_accepted_tokens + config.block_size, porque a Attention primeiro concatenará context_hidden_states e os hidden states derivados de noise_embeds, de modo que os estados k/v não terão o mesmo comprimento que os q_states, mesmo antes da chamada cache.update(). Assim, os position_ids e os position_embeddings derivados precisam cobrir todas as posições adicionais.
past_key_values (~cache_utils.DFlashCache, 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 nos past_key_values retornados pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.
Apenas uma instância de Cache é 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).
use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

BaseModelOutputWithPast ou tuple(torch.FloatTensor)

Um BaseModelOutputWithPast ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (MuseGlimmerAssistantConfig) e das entradas.

O método forward do MuseGlimmerAssistantModel 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.FloatTensor 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.FloatTensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.FloatTensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com formato (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.FloatTensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.FloatTensor (uma para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

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

Update on GitHub

←MuseGlimmer MVP→