Transformers documentation
Mixtral
Este modelo foi publicado no HF papers em 2024-01-08 e contribuído para o Hugging Face Transformers em 2023-12-11.
Mixtral
Visão geral
Mixtral-8x7B foi apresentado no post no blog Mixtral of Experts por Albert Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lélio Renard Lavaud, Lucile Saulnier, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, William El Sayed.
A introdução do post do blog diz:
Hoje, a equipe tem o orgulho de lançar o Mixtral 8x7B, um modelo de alta qualidade do tipo sparse mixture of experts (SMoE) com pesos abertos. Licenciado sob Apache 2.0. O Mixtral supera o Llama 2 70B na maioria dos benchmarks com inferência 6x mais rápida. É o modelo de pesos abertos mais forte com licença permissiva e o melhor modelo no geral em termos de relação custo-desempenho. Em particular, ele iguala ou supera o GPT3.5 na maioria dos benchmarks padrão.
O Mixtral-8x7B é o segundo grande modelo de linguagem (LLM) lançado pela mistral.ai, após o Mistral-7B.
Detalhes da arquitetura
O Mixtral-8x7B é um Transformer somente decodificador com as seguintes escolhas arquitetônicas:
- O Mixtral é um modelo Mixture of Experts (MoE) com 8 especialistas por MLP, totalizando 45 bilhões de parâmetros. Para saber mais sobre mixture-of-experts, consulte o post no blog.
- Apesar de o modelo ter 45 bilhões de parâmetros, o poder de computação necessário para uma única passagem direta é o mesmo de um modelo com 14 bilhões de parâmetros. Isso ocorre porque, embora cada um dos especialistas precise ser carregado na RAM (exigência de RAM de 70B), cada token dos estados ocultos é despachado duas vezes (roteamento top 2) e, portanto, a computação (a operação necessária em cada cálculo de passagem direta) é apenas 2 X sequence_length.
Os seguintes detalhes de implementação são compartilhados com o primeiro modelo da Mistral AI, Mistral-7B:
- Atenção com Janela Deslizante - Treinado com comprimento de contexto de 8k e tamanho de cache fixo, com uma extensão teórica de atenção de 128K tokens
- GQA (Grouped Query Attention) - permitindo inferência mais rápida e menor tamanho de cache.
- Tokenizador BPE com fallback por byte – garante que os caracteres nunca sejam mapeados para tokens fora do vocabulário.
Para mais detalhes, consulte o post de lançamento no blog.
Licença
Mixtral-8x7B é publicado sob a licença Apache 2.0.
Dicas de uso
A equipe Mistral lançou 2 checkpoints:
- um modelo base, Mixtral-8x7B-v0.1, que foi pré-treinado para prever o próximo token em dados de escala da internet.
- um modelo ajustado por instruções, Mixtral-8x7B-Instruct-v0.1, que é o modelo base otimizado para fins de chat usando ajuste fino supervisionado (SFT) e otimização de preferência direta (DPO).
O modelo base pode ser usado da seguinte forma:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"My favourite condiment is to ..."O modelo ajustado por instrução pode ser usado da seguinte forma:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"Mayonnaise can be made as follows: (...)"Como pode ser visto, o modelo ajustado por instrução requer que um chat template seja aplicado para garantir que as entradas sejam preparadas no formato correto.
Acelerando o Mixtral usando Flash Attention
Os trechos de código acima demonstram a inferência sem nenhum truque de otimização. No entanto, é possível acelerar drasticamente o modelo aproveitando o Flash Attention, que é uma implementação mais rápida do mecanismo de atenção usado dentro do modelo.
Primeiro, certifique-se de instalar a versão mais recente do Flash Attention 2 para incluir o recurso de atenção com janela deslizante.
pip install -U flash-attn --no-build-isolation
Certifique-se também de que você possui um hardware compatível com Flash-Attention 2. Leia mais sobre isso na documentação oficial do repositório flash attention. Certifique-se também de carregar seu modelo em meia precisão (por exemplo, torch.float16)
Para carregar e executar um modelo usando Flash Attention-2, consulte o trecho de código abaixo:
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", attn_implementation="flash_attention_2", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"Acelerações esperadas
Abaixo está um diagrama de aceleração esperado que compara o tempo de inferência puro entre a implementação nativa em transformers usando o checkpoint mistralai/Mixtral-8x7B-v0.1 e a versão do modelo com Flash Attention 2.
Atenção com janela deslizante
A implementação atual suporta o mecanismo de atenção com janela deslizante e o gerenciamento de cache eficiente em termos de memória.
Para habilitar a atenção com janela deslizante, basta garantir que você tenha uma versão do flash-attn compatível com a atenção com janela deslizante (>=2.3.0).
O modelo Flash Attention-2 também utiliza um mecanismo de fatiamento de cache mais eficiente em termos de memória - conforme recomendado pela implementação oficial do modelo Mistral, que utiliza um mecanismo de cache rolante, mantemos o tamanho do cache fixo (self.config.sliding_window), suportamos geração em lote apenas para padding_side="left" e usamos a posição absoluta do token atual para calcular o embedding posicional.
Reduzindo o Mixtral usando quantização
Como o modelo Mixtral possui 45 bilhões de parâmetros, isso exigiria cerca de 90GB de RAM de GPU em meia precisão (float16), já que cada parâmetro é armazenado em 2 bytes. No entanto, é possível reduzir o tamanho do modelo usando quantização. Se o modelo for quantizado para 4 bits (ou meio byte por parâmetro), uma única A100 com 40GB de RAM é suficiente para acomodar o modelo inteiro, pois, nesse caso, são necessários apenas cerca de 27 GB de RAM.
Quantizar um modelo é tão simples quanto passar um quantization_config para o modelo. Abaixo, utilizaremos a biblioteca de quantização bitsandbytes (mas consulte esta página para métodos alternativos de quantização):
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype="torch.float16",
)
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", quantization_config=True, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
prompt = "My favourite condiment is"
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"Este modelo foi contribuído por Younes Belkada e Arthur Zucker. O código original pode ser encontrado aqui.
Recursos
Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o Mixtral. Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.
- Um notebook de demonstração para realizar o ajuste fino supervisionado (SFT) do Mixtral-8x7B pode ser encontrado aqui. 🌎
- Um post de blog sobre o ajuste fino do Mixtral-8x7B usando PEFT. 🌎
- O Alignment Handbook da Hugging Face inclui scripts e receitas para realizar fine-tuning supervisionado (SFT) e otimização de preferência direta com o Mistral-7B. Isso inclui scripts para fine-tuning completo, QLoRa em um único acelerador, bem como fine-tuning multiacelerador.
- Guia da tarefa de modelagem de linguagem causal
MixtralConfig
classe transformers.MixtralConfig
< 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 = 32000hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falsesliding_window: int | None = Noneattention_dropout: float | int = 0.0num_experts_per_tok: int = 2num_local_experts: int = 8output_router_logits: bool = Falserouter_aux_loss_coef: float = 0.001router_jitter_noise: float = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None )
Parâmetros
- vocab_size (
int, opcional, padrão32000) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão4096) — Dimensão das representações ocultas. - intermediate_size (
int, opcional, padrão14336) — Dimensão das representações do MLP. - num_hidden_layers (
int, opcional, padrão32) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão32) — 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ão8) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Senum_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); senum_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) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads - 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. - max_position_embeddings (
int, opcional, padrão131072) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - rms_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização rms. - 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. - pad_token_id (
int, opcional) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão1) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - sliding_window (
int, opcional) — Tamanho da janela de atenção deslizante. Se forNone, nenhuma janela deslizante é aplicada. - attention_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para as probabilidades de atenção. - num_experts_per_tok (
int, opcional, padrão2) — Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento de escolha de token. - num_local_experts (
int, opcional, padrão8) — Número de especialistas locais em cada dispositivo.num_expertsdeve ser divisível pornum_local_experts. - output_router_logits (
bool, opcional, padrãoFalse) — Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permitirá que o modelo saída a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador. - router_aux_loss_coef (
float, opcional, padrão0.001) — Coeficiente da perda auxiliar de balanceamento de carga. Usado para penalizar o roteamento desigual de especialistas em modelos MoE. - router_jitter_noise (
float, opcional, padrão0.0) — Quantidade de ruído a ser adicionada aos logits do roteador durante o treinamento para um melhor balanceamento de carga. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores.
Esta é a classe de configuração para armazenar a configuração de um MixtralModel. Ela é usada para instanciar um modelo Mixtral 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 mistralai/Mixtral-8x7B-v0.1
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 MixtralModel, MixtralConfig
>>> # Initializing a Mixtral 7B style configuration
>>> configuration = MixtralConfig()
>>> # Initializing a model from the Mixtral 7B style configuration
>>> model = MixtralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralCommonBackend
classe transformers.MistralCommonBackend
< source >( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Classe para encapsular tokenizadores do mistral-common.
mistral-common é a biblioteca oficial de tokenização para os modelos da Mistral AI. Para usá-la, você precisa instalá-la com:
pip install transformers[mistral-common]
Caso contrário, o tokenizer recorre à implementação do tokenizer da Transformers.
Para mais informações sobre mistral-common, consulte mistral-common.
Esta classe é um wrapper em torno de um mistral_common.tokens.tokenizers.mistral.MistralTokenizer.
Ela fornece uma interface compatível com o Hugging Face para tokenizar usando o tokenizador oficial mistral-common e herda da classe PreTrainedTokenizerBase.
Aqui estão as principais diferenças de comportamento em relação à classe PythonBackend:
- Pares de sequências não são suportados. A assinatura foi mantida por compatibilidade, mas todos os argumentos relacionados a pares de sequências são ignorados. Os valores de retorno para pares são retornados como
None. - O argumento
is_split_into_wordsnão é suportado. - Não é possível adicionar novos tokens ao tokenizer. Os tokens especiais são tratados de forma diferente em Transformers. Em
mistral-common, os tokens especiais nunca são codificados diretamente. Isso significa que:tokenizer.encode("<s>")não retornará o ID do token<s>. Em vez disso, retornará uma lista de IDs correspondente à tokenização da string"<s>". Para mais informações, consulte a documentação do mistral-common.
Se você tiver sugestões para melhorar esta classe, abra uma issue no repositório GitHub mistral-common se estiver relacionada ao tokenizer ou no repositório GitHub Transformers se estiver relacionada à interface do Hugging Face.
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend não implementa add_special_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
MistralCommonBackend não implementa add_special_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]
Parâmetros
- conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — Uma lista de dicts com as chaves “role” e “content”, representando o histórico do chat até o momento.
- tools (
List[Union[Dict, Callable]], opcional) — Uma lista de ferramentas (funções chamáveis) que estarão acessíveis ao modelo. Se o template não suportar function calling, este argumento não terá efeito. Cada ferramenta deve ser passada como um JSON Schema, fornecendo o nome, a descrição e os tipos de argumentos da ferramenta. Consulte nosso guia de chat templating para mais informações. - add_generation_prompt (
bool, opcional) — Este argumento é um no-op paraMistralCommonBackend. No entanto, ele não pode ser usado ao mesmo tempo quecontinue_final_messagepara manter a API consistente. Se alguma conversa terminar com uma mensagem do assistente, será gerado um erro. Nesses casos, usecontinue_final_messageem vez disso. - continue_final_message (bool, opcional) —
Se definido, o chat será formatado de modo que a mensagem final
do chat seja aberta, sem tokens EOS. O modelo continuará essa mensagem
em vez de iniciar uma nova. Isso permite “preencher” parte da
resposta do modelo. Não pode ser usado ao mesmo tempo que
add_generation_prompt. - tokenize (
bool, padrãoTrue) — Se deve tokenizar a saída. SeFalse, a saída será uma string. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool, padrãoFalse) — Se as sequências devem ser truncadas no comprimento máximo. Não tem efeito se tokenize forFalse. - max_length (
int, opcional) — Comprimento máximo (em tokens) a ser usado para padding ou truncamento. Não tem efeito se tokenize forFalse. Se não for especificado, o atributomax_lengthdo tokenizer será usado como padrão. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Não tem efeito se tokenize forFalse. Valores aceitos:'pt': Retorna objetostorch.Tensordo PyTorch.
- return_dict (
bool, padrãoFalse) — Indica se deve retornar um dicionário com saídas nomeadas. Não tem efeito se tokenize forFalse. Se pelo menos uma conversa contiver uma imagem, seus valores de pixel serão retornados na chavepixel_valuese os tamanhos das imagens na chaveimage_sizes. - reasoning_effort (
ReasoningEffort, opcional) — O esforço de raciocínio a ser usado para a conclusão do chat em modelos que o suportam. Os valores possíveis são:ReasoningEffort.none: O modelo não realizará raciocínio.ReasoningEffort.high: O modelo utilizará uma abordagem de raciocínio. Se não for especificado, o esforço de raciocínio padrão será utilizado.
- kwargs (argumentos de palavra-chave adicionais, opcional) —
Argumentos adicionais passados para o método
ChatCompletionRequest.from_openaido mistral-common.
Retorna
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
O chat tokenizado até o momento, incluindo os tokens de controle. Esta saída está pronta para ser passada ao modelo, seja diretamente ou por meio de métodos como generate().
Converte uma lista de dicionários com as chaves "role" e "content" em uma lista de ids de tokens.
batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
Parâmetros
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Pode ser obtida usando o método__call__. - skip_special_tokens (
bool, opcional, padrãoFalse) — Indica se os tokens especiais devem ser removidos durante a decodificação. - clean_up_tokenization_spaces (
bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se forNone, o valor padrão seráself.clean_up_tokenization_spaces. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.batch_decode. Acionará um erro se for usado.
Retorna
list[str]
A lista de frases decodificadas.
Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.
Este método é fornecido para compatibilidade reversa. O método decode agora processa entradas em lote nativamente,
então você pode usar decode diretamente em vez de batch_decode.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Construa as entradas do modelo a partir de uma sequência adicionando tokens especiais.
Este método constrói dinamicamente as entradas com base no mode do tokenizer:
"test": seq0 [EOS]"finetuning": [BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend não implementa convert_added_tokens por design.
Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Crie uma máscara de zeros a partir dos ids de tokens com os tokens especiais adicionados.
Mantido para corresponder à implementação do Transformers.
decode
< source >( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]
Parâmetros
- token_ids (
Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Uma única sequência ou um lote (lista de sequências) de ids de entrada tokenizados. Pode ser obtido usando o método__call__. - skip_special_tokens (
bool, opcional, padrãoFalse) — Indica se os tokens especiais devem ser removidos durante a decodificação. - clean_up_tokenization_spaces (
bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se forNone, o valor padrão seráself.clean_up_tokenization_spaces. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.decode. Acionará um erro se for usado.
Retorna
Union[str, list[str]]
A string decodificada para uma única sequência, ou uma lista de strings decodificadas para um lote de sequências.
Converte uma sequência de ids em uma string, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização.
encode
< source >( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor
Parâmetros
- text (
stroulist[int]) — A primeira sequência a ser codificada. Pode ser uma string ou uma lista de inteiros (ids de string tokenizada). - text_pair (
None, opcional) — Não é suportado porMistralCommonBackend.encode. Mantido para corresponder à assinatura dePreTrainedTokenizerBase.encode. - add_special_tokens (
bool, opcional, padrãoTrue) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokensbosoueosautomaticamente. Quando o Tokenizer é carregado no modofinetuning, ele adiciona tantobosquantoeos. Caso contrário, no modo “test”, ele adiciona apenasbos. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - stride (
int, opcional, padrão 0) — Se definido como um número junto commax_length, os tokens excedentes retornados quandoreturn_overflowing_tokens=Trueconterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos. - pad_to_multiple_of (
int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige quepaddingesteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação>= 7.5(Volta). - padding_side (
str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.
- **kwargs — Não suportado por
MistralCommonBackend.encode. Acionará um erro se for usado.
Retorna
list[int], torch.Tensor
Os ids tokenizados do texto.
Converte uma string em uma sequência de ids (inteiros), usando o tokenizer e o vocabulário.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Parâmetros
- pretrained_model_name_or_path (
strouos.PathLike) — Pode ser:- Uma string, o model id de um tokenizer predefinido hospedado em um repositório de modelos no huggingface.co.
- Um caminho para um diretório contendo a configuração do tokenizer, por exemplo, salvo
usando o método
MistralCommonBackend.tokenization_mistral_common.save_pretrained, por exemplo,./my_model_directory/.
- mode (
Union[str, ValidationMode], opcional, padrão éValidationMode.test) — Modo de validação para oMistralTokenizertokenizer. Os valores possíveis são:"finetuning"ouValidationMode.finetuning: o modo de ajuste fino."test"ouValidationMode.test: o modo de teste. Ele altera a forma como o tokenizer valida a entrada e prepara a solicitação ao modelo.
- cache_dir (
strouos.PathLike, opcional) — Caminho para um diretório em que os arquivos de vocabulário de um tokenizer predefinido baixado devem ser armazenados em cache, caso o cache padrão não deva ser usado. - force_download (
bool, opcional, padrãoFalse) — Se deve forçar o (re-)download dos arquivos de vocabulário e substituir as versões em cache, caso existam. - token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, usará o token gerado ao executarhf auth login(armazenado em~/.huggingface). - local_files_only (
bool, opcional, padrãoFalse) — Indica se deve-se confiar apenas em arquivos locais e não tentar baixar nenhum arquivo. - revision (
str, opcional, padrão"main") — A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois utilizamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, de modo querevisionpode ser qualquer identificador permitido pelo git. - max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - padding_side (
str, opcional, padrão"left") — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - truncation_side (
str, opcional, padrão"right") — O lado em que o modelo deve ter a truncagem aplicada. Deve ser selecionado entre [‘right’, ‘left’]. - model_input_names (
List[str], opcional) — A lista de entradas aceitas pela passagem direta do modelo (como"token_type_ids"ou"attention_mask"). O valor padrão é obtido do atributo de classe com o mesmo nome. - clean_up_tokenization_spaces (
bool, opcional, padrãoFalse) — Se o modelo deve ou não limpar os espaços que foram adicionados ao dividir o texto de entrada durante o processo de tokenização. - kwargs (argumentos de palavra-chave adicionais, opcional) —
Não é suportado por
MistralCommonBackend.from_pretrained. Acionará um erro se for usado.
Instancie um MistralCommonBackend a partir de um
tokenizer predefinido.
MistralCommonBackend não implementa get_chat_template por design, pois mistral-common não utiliza modelos de chat.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Parâmetros
- token_ids_0 (
list[int]) — Lista de ids da sequência. - token_ids_1 (
None, opcional) — None, mantido para corresponder à implementação do Transformers. - already_has_special_tokens (
bool, opcional, padrãoFalse) — Indica se a lista de tokens já está formatada com tokens especiais para o modelo.
Retorna
Uma lista de inteiros no intervalo [0, 1]
1 para um token especial, 0 para um token de sequência.
Recupera os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Este método é chamado ao adicionar tokens especiais usando os métodos prepare_for_model ou encode_plus do tokenizer.
Retorna o vocabulário como um dicionário de token para índice.
Esta é uma conversão com perda de dados. Pode haver vários ids de token que decodificam para a mesma string, devido a sequências parciais de bytes UTF-8 sendo convertidas em �.
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
Retorna o número de tokens adicionados ao codificar uma sequência com tokens especiais.
Isso codifica uma entrada fictícia e verifica o número de tokens adicionados, e portanto não é eficiente. Não coloque isso dentro do seu loop de treinamento.
prepare_for_model
< source >( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding
Parâmetros
- ids (
list[int]) — IDs de entrada tokenizados da primeira sequência. - pair_ids (
None, opcional) — Não é suportado peloMistralCommonBackend. Mantido para corresponder à interface doPreTrainedTokenizerBase. - add_special_tokens (
bool, opcional, padrãoTrue) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokensbosoueosautomaticamente. Quando o Tokenizer é carregado no modofinetuning, ele adiciona tantobosquantoeos. Caso contrário, no modo “test”, ele adiciona apenasbos. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - stride (
int, opcional, padrão 0) — Se definido como um número junto commax_length, os tokens excedentes retornados quandoreturn_overflowing_tokens=Trueconterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos. - pad_to_multiple_of (
int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige quepaddingesteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação>= 7.5(Volta). - padding_side (
str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.
- return_token_type_ids (
bool, opcional) — Se deve retornar os IDs de tipo de token. ParaMistralCommonBackendele retorna uma lista de zeros com o comprimento da sequência, pois apenas uma sequência é suportada. - return_attention_mask (
bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributoreturn_outputs. - return_overflowing_tokens (
bool, opcional, padrãoFalse) — Indica se as sequências de tokens excedentes devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido comtruncation_strategy = longest_firstouTrue, um erro será lançado em vez de retornar os tokens excedentes. - return_special_tokens_mask (
bool, opcional, padrãoFalse) — Indica se a máscara de tokens especiais deve ser retornada. - return_length (
bool, opcional, padrãoFalse) — Indica se as comprimentos das entradas codificadas devem ser retornados. - verbose (
bool, opcional, padrãoTrue) — Se deve ou não exibir mais informações e avisos. - return_offsets_mapping (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - split_special_tokens (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - **kwargs — passados para o método
self.tokenize()
Retorna
Um BatchEncoding com os seguintes campos:
-
input_ids — Lista de ids de tokens a serem fornecidos a um modelo.
-
attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando
return_attention_mask=Trueou se “attention_mask” estiver emself.model_input_names). -
overflowing_tokens — Lista de sequências de tokens excedentes (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (quando um
max_lengthé especificado ereturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando
add_special_tokens=Trueereturn_special_tokens_mask=True). -
length — O comprimento das entradas (quando
return_length=True)
Prepara uma sequência de ids de entrada para que possa ser usada pelo modelo. Adiciona tokens especiais, truncando sequências em caso de estouro, considerando os tokens especiais, e gerencia uma janela móvel (com passo definido pelo usuário) para tokens que excedem o limite.
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend não implementa save_chat_templates por design, pois mistral-common não utiliza chat templates.
save_pretrained
< source >( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]
Parâmetros
- save_directory (
str | os.PathLike | Path) — Diretório onde o tokenizer será salvo. - push_to_hub (
bool, opcional, padrãoFalse) — Envia para o HF Hub após salvar. - token (
stroubool, opcional) — Token para autenticação no Hub. - commit_message (
str, opcional) — Mensagem de commit ao fazer push. - repo_id (
str, opcional) — ID do repositório no Hub. - private (
bool, opcional) — Indica se o repositório é privado. - save_format (
str, opcional) —"mistral"para salvar no formato nativo tekken,"hf"para o formato HuggingFace. None preserva o formato original. - kwargs (
dict, opcional) — Não suportado — lançará um erro.
Retorna
tuple[str, ...]
Caminhos dos arquivos salvos.
Salve o estado completo do tokenizer.
Quando save_format é "mistral" (ou None para um tokenizer tekken),
o arquivo original do tokenizer (por exemplo, tekken.json) é gravado em save_directory. Quando save_format é "hf", os arquivos em formato HF
(tokenizer.json + tokenizer_config.json) são gerados em vez disso.
MistralCommonBackend não implementa save_vocabulary por design.
Isso ocorre porque o mistral-common é configurado por um único arquivo de tokenizer. Se você deseja salvar o vocabulário, considere usar o método save_pretrained em vez disso.
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
Parâmetros
- text (
str) — A sequência a ser codificada. - return_offsets_mapping (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - split_special_tokens (
Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers. - **kwargs (argumentos de palavra-chave adicionais) —
Não suportado por
MistralCommonBackend.tokenize. Acionará um erro se for usado.
Retorna
list[str]
A lista de tokens.
Converte uma string em uma sequência de tokens, usando o tokenizer.
Divida em palavras para vocabulários baseados em palavras ou em subpalavras para vocabulários baseados em subpalavras.
truncate_sequences
< source >( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]
Parâmetros
- ids (
list[int]) — IDs de entrada tokenizados. Podem ser obtidos a partir de uma string encadeando os métodostokenizeeconvert_tokens_to_ids. - pair_ids (
None, opcional) — Não é suportado peloMistralCommonBackend. Mantido para corresponder à assinatura dePreTrainedTokenizerBase.truncate_sequences. - num_tokens_to_remove (
int, opcional, padrão 0) — Número de tokens a serem removidos usando a estratégia de truncamento. - truncation_strategy (
strou TruncationStrategy, opcional, padrão é'longest_first') — A estratégia a ser seguida para a truncagem. Pode ser:'longest_first': Trunca para o comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceito pelo modelo).
- stride (
int, opcional, padrão 0) — Se definido como um número positivo, os tokens de estouro retornados incluirão alguns tokens da sequência principal retornada. O valor deste argumento define o número de tokens adicionais.
Retorna
Tuple[list[int], None, list[int]]
Os ids truncados e a lista de
tokens que excedem o limite. None é retornado para corresponder à assinatura do Transformers.
Trunca um par de sequências no local, seguindo a estratégia.
MixtralModel
classe transformers.MixtralModel
< source >( config: MixtralConfig )
Parâmetros
- config (MixtralConfig) — 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 Mixtral puro, 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeModelOutputWithPast or tuple(torch.FloatTensor)
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.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde 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 incorporação interna do modelo. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
MoeModelOutputWithPast ou tuple(torch.FloatTensor)
Uma MoeModelOutputWithPast 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 (MixtralConfig) e das entradas.
O método forward do MixtralModel 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.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.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 entradapast_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
router_logits (
tuple(torch.FloatTensor), opcional, retornado quandooutput_router_probs=Trueeconfig.add_router_probs=Truesão passados ou quandoconfig.output_router_probs=True) — Tupla detorch.FloatTensor(uma para cada camada) com forma(batch_size, sequence_length, num_experts).Logits brutos do roteador (pós-softmax) calculados pelos roteadores MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.
MixtralForCausalLM
classe transformers.MixtralForCausalLM
< source >( config: MixtralConfig )
Parâmetros
- config (MixtralConfig) — 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 Mixtral para modelagem de linguagem causal.
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.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_router_logits: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeCausalLMOutputWithPast or tuple(torch.FloatTensor)
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.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - 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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde 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 incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - output_router_logits (
bool, opcional) — Indica se os logits de todos os roteadores devem ser retornados. Eles são úteis para calcular a perda do roteador e não devem ser retornados durante a inferência. - 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
MoeCausalLMOutputWithPast ou tuple(torch.FloatTensor)
Um MoeCausalLMOutputWithPast 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 (MixtralConfig) e das entradas.
O método forward de MixtralForCausalLM 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.FloatTensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.FloatTensorde 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).aux_loss (
torch.FloatTensor, opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.output_router_logits=True, e o modelo treina seu roteador com uma perda de balanceamento de carga) — Perda auxiliar de balanceamento de carga para os módulos esparsos. Modelos que equilibram seus especialistas com um viés de roteador em vez disso (DeepSeek-V3 e as arquiteturas derivadas dele) retornamNoneaqui, mas ainda retornamrouter_logits.router_logits (
tuple(torch.FloatTensor), opcional, retornado quandooutput_router_logits=Trueé passado ou quandoconfig.output_router_logits=True) — Tupla detorch.FloatTensor(uma para cada camada esparsa) com forma(batch_size * sequence_length, num_experts).Logits brutos do roteador calculados pelos roteadores MoE. Podem ser usados para calcular uma perda de balanceamento de carga ou para inspecionar como os tokens são distribuídos entre os especialistas.
past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.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.FloatTensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
Exemplo:
>>> from transformers import AutoTokenizer, MixtralForCausalLM
>>> model = MixtralForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."MixtralForSequenceClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.FloatTensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → SequenceClassifierOutputWithPast
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.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde 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 incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
SequenceClassifierOutputWithPast
O método forward da GenericForSequenceClassification 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.
MixtralForTokenClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.FloatTensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → TokenClassifierOutput
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.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde 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 incorporação interna do modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de classificação de tokens. Os índices devem estar em[0, ..., config.num_labels - 1]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values).
Retorna
TokenClassifierOutput
O método forward de GenericForTokenClassification 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
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.
MixtralForQuestionAnswering
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.FloatTensor | None = Nonestart_positions: torch.LongTensor | None = Noneend_positions: torch.LongTensor | None = None**kwargs: Unpack[TransformersKwargs] ) → QuestionAnsweringModelOutput
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.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
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 nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnã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 osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde 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 incorporação interna do modelo. - start_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda. - end_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do final do trecho rotulado, para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda.
Retorna
QuestionAnsweringModelOutput
O método GenericForQuestionAnswering forward 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
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.