Transformers documentation
Mamba
Este modelo foi publicado no HF papers em 2023-12-01 e contribuído para o Hugging Face Transformers em 2024-03-05.
Mamba
Mamba é um modelo de espaço de estado estruturado seletivo (SSMs) projetado para contornar a ineficiência computacional dos Transformers ao lidar com sequências longas. Trata-se de uma arquitetura totalmente sem atenção, composta por uma combinação de blocos H3 e MLPs com gate (bloco Mamba). O “raciocínio baseado em conteúdo” do Mamba permite que ele foque em partes específicas de uma entrada, dependendo do token atual. O Mamba também utiliza um novo algoritmo paralelo consciente do hardware para compensar a ausência de operações convolucionais. Como resultado, o Mamba possui inferência rápida e pode escalar para sequências muito longas.
Você pode encontrar todos os checkpoints originais do Mamba na organização State Space Models.
Este modelo foi contribuído por Molbap e AntonV. Clique nos modelos Mamba na barra lateral à direita para ver mais exemplos de como aplicar o Mamba a diferentes tarefas de linguagem.
O exemplo abaixo demonstra como gerar texto com Pipeline, AutoModel e pela linha de comando.
from transformers import pipeline
pipeline = pipeline(
task="text-generation",
model="state-spaces/mamba-130m-hf",
device=0
)
pipeline("Plants create energy through a process known as")from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("state-spaces/mamba-130m-hf")
model = AutoModelForCausalLM.from_pretrained("state-spaces/mamba-130m-hf", device_map="auto")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to(model.device)
output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de Quantização para mais backends de quantização disponíveis.
O exemplo abaixo usa torchao para quantizar apenas os pesos para inteiros de 4 bits.
from torchao.quantization import Int4WeightOnlyConfig
from transformers import AutoModelForCausalLM, AutoTokenizer, TorchAoConfig
quantization_config = Int4WeightOnlyConfig(group_size=128)
quantization_config = TorchAoConfig(quant_type=quant_config)
tokenizer = AutoTokenizer.from_pretrained("state-spaces/mamba-2.8b-hf")
model = AutoModelForCausalLM.from_pretrained("state-spaces/mamba-2.8b-hf", quantization_config=quantization_config, device_map="auto")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to(model.device)
output = model.generate(**input_ids)
print(tokenizer.decode(output[0], skip_special_tokens=True))Observações
A implementação atual utiliza os kernels CUDA originais. A implementação equivalente do FlashAttention está hospedada nos repositórios mamba-ssm e causal_conv1d. Certifique-se de instalá-los, caso seu hardware ofereça suporte!
As pilhas Mamba
mixersão camadas equivalentes a camadas deAttention. Você pode encontrar a lógica principal do Mamba na classeMambaMixer.O exemplo abaixo demonstra como fazer o ajuste fino do Mamba com PEFT.
from datasets import load_dataset from trl import SFTConfig, SFTTrainer from peft import LoraConfig model_id = "state-spaces/mamba-130m-hf" dataset = load_dataset("Abirate/english_quotes", split="train") training_args = SFTConfig(dataset_text_field="quote") lora_config = LoraConfig(target_modules=["x_proj", "embeddings", "in_proj", "out_proj"]) trainer = SFTTrainer( model=model_id, args=training_args, train_dataset=dataset, peft_config=lora_config, ) trainer.train()Use padding à esquerda para geração em lote. Consulte Lado do padding.
MambaConfig
classe transformers.MambaConfig
< 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 = Nonevocab_size: int = 50280hidden_size: int = 768state_size: int = 16num_hidden_layers: int = 32layer_norm_epsilon: float = 1e-05pad_token_id: int | None = 0bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 0expand: int = 2conv_kernel: int = 4use_bias: bool = Falseuse_conv_bias: bool = Truehidden_act: str = 'silu'initializer_range: float = 0.1residual_in_fp32: bool = Truetime_step_rank: str | int = 'auto'time_step_scale: float = 1.0time_step_min: float = 0.001time_step_max: float = 0.1time_step_init_scheme: str = 'random'time_step_floor: float = 0.0001rescale_prenorm_residual: bool = Falseuse_cache: bool = Trueuse_mambapy: bool = Falseuse_associative_scan: bool = Truetie_word_embeddings: bool = True )
Parâmetros
- vocab_size (
int, opcional, padrão50280) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão768) — Dimensão das representações ocultas. - state_size (
int, opcional, padrão16) — Tamanho do estado do SSM (dimensão do estado latente) nas camadas Mamba. - num_hidden_layers (
int, opcional, padrão32) — Número de camadas ocultas no decodificador do Transformer. - layer_norm_epsilon (
float, opcional, padrão 1e-05) — O epsilon a ser usado nas camadas de normalização de camada. - pad_token_id (
int, opcional, padrão0) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão0) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão0) — ID do token usado para o fim do fluxo no vocabulário. - expand (
int, opcional, padrão 2) — Fator de expansão usado para determinar o tamanho intermediário. - conv_kernel (
int, opcional, padrão4) — O tamanho do kernel de convolução. - use_bias (
bool, opcional, padrãoFalse) — Indica se deve ou não usar viés em ["in_proj", "out_proj"] do bloco mixer - use_conv_bias (
bool, opcional, padrãoTrue) — Indica se deve ou não usar viés na camada de convolução do bloco do mixer. - hidden_act (
str, opcional, padrãosilu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - initializer_range (
float, opcional, padrão0.1) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - residual_in_fp32 (
bool, opcional, padrãoTrue) — Indica se os resíduos devem estar emfloat32. Se definido comoFalse, os resíduos manterão o mesmodtypedo restante do modelo - time_step_rank (
Union[str, int], opcional, padrãoauto) — Rank da projeção do delta (time step). Pode ser"auto"para definir automaticamente. - time_step_scale (
float, opcional, padrão1.0) — Escala aplicada ao delta do passo de tempo antes da discretização. - time_step_min (
float, opcional, padrão0.001) — Valor mínimo detime_stepusado para limitardt_proj.bias. - time_step_max (
float, opcional, padrão0.1) — Valor máximo detime_stepusado para limitardt_proj.bias. - time_step_init_scheme (
str, opcional, padrãorandom) — Esquema de inicialização para o delta do passo de tempo. Pode ser"random"ou"uniform". - time_step_floor (
float, opcional, padrão0.0001) — Valor mínimo permitido para o delta do passo de tempo discreto após a ativação softplus. - rescale_prenorm_residual (
bool, opcional, padrãoFalse) — Se as pesos deout_projdevem ser reescalados durante a inicialização. - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - use_mambapy (
bool, opcional, padrãoFalse) — Determina a estratégia de fallback durante o treinamento caso a implementação oficial baseada em CUDA do Mamba não esteja disponível. SeTrue, a implementação mamba.py é utilizada. SeFalse, a implementação ingênua e mais lenta é utilizada. Considere alternar para a versão ingênua caso a memória seja limitada. - use_associative_scan (
bool, opcional, padrãoTrue) — Se deve usar otorch._higher_order_ops.associative_scando PyTorch para o scan paralelo em vez da implementação sequencial ingênua. O scan associativo está ativo apenas durante o tracing dotorch.compilee requer torch >= 2.9.0. Ambos os caminhos são testados para produzir resultados numericamente idênticos (vejatest_associative_scan_matches_sequential). Defina comoFalsepara usar o loop sequencial. - tie_word_embeddings (
bool, opcional, padrãoTrue) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo.
Esta é a classe de configuração para armazenar a configuração de um MambaModel. Ela é usada para instanciar um modelo Mamba 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 state-spaces/mamba-2.8b
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 MambaConfig, MambaModel
>>> # Initializing a Mamba configuration
>>> configuration = MambaConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = MambaModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMambaModel
classe transformers.MambaModel
< source >( config: MambaConfig )
Parâmetros
- config (MambaConfig) — 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 Mamba puro, que produz 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.LongTensor] = Nonecache_params: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Noneattention_mask: typing.Optional[torch.LongTensor] = None**kwargs ) → MambaOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde 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.
- inputs_embeds (
torch.LongTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - cache_params (
Cache, opcional) — Se for passado, o modelo usa o estado anterior em todos os blocos (o que resultará na saída para osinput_idsfornecidos, como se o modelo adicionassestate_input_ids + input_idscomo contexto). - use_cache (
bool, opcional) — Se definido comoTrue, ocache_paramsé retornado e pode ser usado para gerar rapidamente os próximos logits. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - attention_mask (
torch.LongTensorde 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.
Retorna
MambaOutput ou tuple(torch.Tensor)
Um MambaOutput 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 (MambaConfig) e das entradas.
O método forward do MambaModel 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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do modelo.cache_params (
~cache_utils.Cache, opcional) — O estado do modelo no último passo de tempo. Pode ser usado em um método forward com o próximoinput_idspara evitar fornecer osinput_idsantigos.Inclui tanto as matrizes de estado do modelo de espaço de estados após o scan seletivo quanto os estados convolucionais
hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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.
MambaLMHeadModel
classe transformers.MambaForCausalLM
< source >( config: MambaConfig )
Parâmetros
- config (MambaConfig) — 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 transformer do modelo MAMBA com uma cabeça de modelagem de linguagem no topo (camada linear com pesos vinculados aos embeddings de entrada).
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonecache_params: transformers.cache_utils.Cache | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → MambaCausalLMOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde 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.
- attention_mask (
torch.LongTensorde 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.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - cache_params (
Cache, opcional) — Se for passado, o modelo usa o estado anterior em todos os blocos (o que resultará na saída para osinput_idsfornecidos, como se o modelo adicionassestate_input_ids + input_idscomo contexto). - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para modelagem de linguagem. Observe que os rótulos são deslocados dentro do modelo, ou seja, você pode definirlabels = input_idsOs índices são selecionados em[-100, 0, ..., config.vocab_size]Todos os rótulos definidos como-100são ignorados (mascarados); a perda é calculada apenas para rótulos em[0, ..., config.vocab_size] - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples. - use_cache (
bool, opcional) — Se definido comoTrue, ocache_paramsé retornado e pode ser usado para gerar rapidamente os próximos logits. - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).
Retorna
MambaCausalLMOutput ou tuple(torch.Tensor)
Um MambaCausalLMOutput 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 (MambaConfig) e das entradas.
O método forward de MambaForCausalLM 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, 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).cache_params (
~cache_utils.Cache, opcional) — O estado do modelo no último passo de tempo. Pode ser usado em um método forward com o próximoinput_idspara evitar fornecer osinput_idsantigos.Inclui tanto as matrizes de estado do modelo de espaço de estados após o scan seletivo quanto os estados convolucionais
hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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.