# Mixtral ## Visão geral [Mixtral-8x7B](https://huggingface.co/papers/2401.04088) foi apresentado no [post no blog Mixtral of Experts](https://mistral.ai/news/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](https://mistral.ai/), após o [Mistral-7B](mistral). ### 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](https://huggingface.co/blog/moe). - 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](mistral): - 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](https://mistral.ai/news/mixtral-of-experts/). ### 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](https://huggingface.co/mistralai/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](https://huggingface.co/mistralai/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: ```python 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: ```python 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](../chat_templating) 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](../kernel_doc/loading_kernels#attention-kernels), 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. ```bash 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](https://github.com/Dao-AILab/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: ```python 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 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](../quantization/overview). 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](../quantization/overview) para métodos alternativos de quantização): ```python 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](https://huggingface.co/ybelkada) e [Arthur Zucker](https://huggingface.co/ArthurZ). O código original pode ser encontrado [aqui](https://github.com/mistralai/mistral-src). ## 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](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Mistral/Supervised_fine_tuning_(SFT)_of_an_LLM_using_Hugging_Face_tooling.ipynb). 🌎 - Um [post de blog](https://medium.com/@prakharsaxena11111/finetuning-mixtral-7bx8-6071b0ebf114) sobre o ajuste fino do Mixtral-8x7B usando PEFT. 🌎 - O [Alignment Handbook](https://github.com/huggingface/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](../tasks/language_modeling) ## MixtralConfig[[transformers.MixtralConfig]] #### transformers.MixtralConfig[[transformers.MixtralConfig]] ```python transformers.MixtralConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, hidden_size: int = 4096, intermediate_size: int = 14336, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = False, sliding_window: int | None = None, attention_dropout: float | int = 0.0, num_experts_per_tok: int = 2, num_local_experts: int = 8, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, router_jitter_noise: float = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/configuration_mixtral.py#L25) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `32000`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `14336`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `32`) : 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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). 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ão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *opcional*, padrão `131072`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. bos_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. sliding_window (`int`, *opcional*) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. num_experts_per_tok (`int`, *opcional*, padrão `2`) : Número de especialistas para os quais cada token será roteado. Este é o valor top-k para o roteamento de escolha de token. num_local_experts (`int`, *opcional*, padrão `8`) : Número de especialistas locais em cada dispositivo. `num_experts` deve ser divisível por `num_local_experts`. output_router_logits (`bool`, *opcional*, padrão `False`) : Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permite que o modelo outpute a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador. router_aux_loss_coef (`float`, *opcional*, padrão `0.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ão `0.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 para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. 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](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> 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.config ``` ## MistralCommonBackend[[transformers.MistralCommonBackend]] #### transformers.MistralCommonBackend[[transformers.MistralCommonBackend]] ```python transformers.MistralCommonBackend(tokenizer_path: str | os.PathLike | pathlib.Path, mode: str | ValidationMode = 'test', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L194) 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: ```bash 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](https://github.com/mistralai/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_words` nã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("")` não retornará o ID do token ``. Em vez disso, retornará uma lista de IDs correspondente à tokenização da string `""`. Para mais informações, consulte a [documentação do mistral-common](https://mistralai.github.io/mistral-common/usage/tokenizers/#special-tokens). Se você tiver sugestões para melhorar esta classe, abra uma issue no [repositório GitHub mistral-common](https://github.com/mistralai/mistral-common/issues) se estiver relacionada ao tokenizer ou no [repositório GitHub Transformers](https://github.com/huggingface/transformers/issues) se estiver relacionada à interface do Hugging Face. #### add_special_tokens[[transformers.MistralCommonBackend.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1679) `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. #### add_tokens[[transformers.MistralCommonBackend.add_tokens]] ```python add_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1691) `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[[transformers.MistralCommonBackend.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | collections.abc.Callable] | None = None, add_generation_prompt: bool = False, continue_final_message: bool = False, tokenize: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_dict: bool = True, reasoning_effort: ReasoningEffort | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1038) **Parâmetros:** conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) : Uma lista de dicionários 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 chamadas de função, 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](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) para mais informações. add_generation_prompt (`bool`, *opcional*) : Este argumento é um no-op para `MistralCommonBackend`. No entanto, ele não pode ser usado ao mesmo tempo que `continue_final_message` para manter a API consistente. Se qualquer conversa terminar com uma mensagem do assistente, será gerado um erro. Nesses casos, use `continue_final_message` em vez disso. continue_final_message (bool, *opcional*) : Se definido, o chat será formatado de modo que a mensagem final no 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ão `True`) : Se deve tokenizar a saída. Se `False`, a saída será uma string. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.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: - `True` ou `'longest'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode retornar um lote com sequências de comprimentos diferentes). truncation (`bool`, padrão `False`) : Se as sequências devem ser truncadas no comprimento máximo. Não tem efeito se tokenize for `False`. max_length (`int`, *opcional*) : Comprimento máximo (em tokens) a ser usado para preenchimento ou truncamento. Não tem efeito se tokenize for `False`. Se não for especificado, o atributo `max_length` do tokenizer será usado como padrão. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Não tem efeito se tokenize for `False`. Valores aceitáveis são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. return_dict (`bool`, padrão `False`) : Se deve retornar um dicionário com saídas nomeadas. Não tem efeito se tokenize for `False`. Se pelo menos uma conversa contiver uma imagem, seus valores de pixel serão retornados na chave `pixel_values` e os tamanhos das imagens na chave `image_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 usará 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_openai` do 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[[transformers.MistralCommonBackend.batch_decode]] ```python batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L512) **Parâmetros:** sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`. skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação. clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização. Se `None`, o padrão será `self.clean_up_tokenization_spaces`. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Não suportado por `MistralCommonBackend.batch_decode`. Gerará um erro se utilizado. **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, portanto, você pode usar `decode` diretamente em vez de `batch_decode`. #### build_inputs_with_special_tokens[[transformers.MistralCommonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1284) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs aos quais os tokens especiais serão adicionados. token_ids_1 (`None`, *opcional*) : None, mantido para corresponder à assinatura do Transformers. **Retorna:** `list[int]` Lista de IDs de entrada com os tokens especiais apropriados. 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[[transformers.MistralCommonBackend.convert_added_tokens]] ```python convert_added_tokens(obj: tokenizers.AddedToken | typing.Any, save: bool = False, add_type_field: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1704) `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. #### criar_ids_de_tipo_de_token_a_partir_de_sequências[[transformers.MistralCommonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1313) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs. token_ids_1 (`None`, *opcional*) : None, mantido para corresponder à assinatura do Transformers. **Retorna:** `list[int]` IDs de tipo de token de acordo com o padrão configurado. 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[[transformers.MistralCommonBackend.decode]] ```python decode(token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L475) **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ão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação. clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização. Se `None`, o padrão será `self.clean_up_tokenization_spaces`. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Não suportado por `MistralCommonBackend.decode`. Gerará um erro se utilizado. **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[[transformers.MistralCommonBackend.encode]] ```python encode(text: str | list[int], text_pair: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, verbose: bool = True, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L378) **Parâmetros:** text (`str` ou `list[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 por `MistralCommonBackend.encode`. Mantido para corresponder à assinatura de `PreTrainedTokenizerBase.encode`. add_special_tokens (`bool`, *opcional*, padrão `True`) : Se deve ou não adicionar tokens especiais ao codificar as sequências. Isso usará a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você quiser adicionar automaticamente tokens `bos` ou `eos`. Quando o Tokenizer é carregado no modo `finetuning`, ele adiciona tanto `bos` quanto `eos`. Caso contrário, no modo "test", ele adiciona apenas `bos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissí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`, será usado 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 até um comprimento máximo será desativado. stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. 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 que `padding` esteja 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 padding aplicado. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Valores aceitáveis são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - ****kwargs** : Não suportado por `MistralCommonBackend.encode`. Gerará 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[[transformers.MistralCommonBackend.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, mode: str | ValidationMode = 'test', cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1437) **Parâmetros:** pretrained_model_name_or_path (`str` ou `os.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`, e.g., `./my_model_directory/`. mode (`Union[str, ValidationMode]`, *opcional*, padrão `ValidationMode.test`) : Modo de validação para o tokenizador `MistralTokenizer`. Os valores possíveis são: - `"finetuning"` ou `ValidationMode.finetuning`: O modo de fine-tuning. - `"test"` ou `ValidationMode.test`: O modo de teste. Isso altera como o tokenizador valida a entrada e prepara a solicitação para o modelo. cache_dir (`str` ou `os.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ão `False`) : Indica se deve forçar o (re-)download dos arquivos de vocabulário e substituir as versões em cache, caso existam. token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`). local_files_only (`bool`, *opcional*, padrão `False`) : 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, portanto `revision` pode 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`, será usado 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 até um comprimento máximo será desativado. padding_side (`str`, *opcional*, padrão `"left"`) : O lado em que o modelo deve ter 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ão `False`) : 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`. Gerará um erro se utilizado. Instancie um `MistralCommonBackend` a partir de um tokenizer predefinido. #### get_chat_template[[transformers.MistralCommonBackend.get_chat_template]] ```python get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1713) `MistralCommonBackend` não implementa `get_chat_template` por design, pois `mistral-common` não utiliza modelos de chat. #### get_special_tokens_mask[[transformers.MistralCommonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L691) **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ão `False`) : 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. #### get_vocab[[transformers.MistralCommonBackend.get_vocab]] ```python get_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L352) **Retorna:** `Dict[str, int]` O vocabulário. 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 tokens que decodificam para a mesma string, devido a sequências parciais de bytes UTF-8 sendo convertidas para �. #### num_special_tokens_to_add[[transformers.MistralCommonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: typing.Literal[False] = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1337) **Parâmetros:** pair (`Literal[False]`, *opcional*) : False, mantido para corresponder à assinatura do Transformer. **Retorna:** `int` Número de tokens especiais adicionados às sequências. 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[[transformers.MistralCommonBackend.prepare_for_model]] ```python prepare_for_model(ids: list, pair_ids: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_length: bool = False, verbose: bool = True, prepend_batch_axis: bool = False, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L844) **Parâmetros:** ids (`list[int]`) : IDs de entrada tokenizada da primeira sequência. pair_ids (`None`, *opcional*) : Não suportado pelo `MistralCommonBackend`. Mantido para corresponder à interface de `PreTrainedTokenizerBase`. add_special_tokens (`bool`, *opcional*, padrão `True`) : Se deve ou não adicionar tokens especiais ao codificar as sequências. Isso usará a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você quiser adicionar automaticamente tokens `bos` ou `eos`. Quando o Tokenizer é carregado no modo `finetuning`, ele adiciona tanto `bos` quanto `eos`. Caso contrário, no modo "test", ele adiciona apenas `bos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissí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`, será usado 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 até um comprimento máximo será desativado. stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. 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 que `padding` esteja 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 padding aplicado. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Valores aceitáveis são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Para `MistralCommonBackend`, retorna uma lista de zeros do comprimento da sequência, pois apenas uma sequência é suportada. [O que são IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são máscaras de atenção?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes. return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais. return_length (`bool`, *opcional*, padrão `False`) : Indica se as comprimentos das entradas codificadas devem ser retornados. verbose (`bool`, *opcional*, padrão `True`) : 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:** [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) com os seguintes campos: - **input_ids** -- Lista de ids de tokens a serem fornecidos a um modelo. [O que são IDs de entrada?](../glossary#input-ids) - **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando `return_attention_mask=True` ou se *"attention_mask"* estiver em `self.model_input_names`). [O que são máscaras de atenção?](../glossary#attention-mask) - **overflowing_tokens** -- Lista de sequências de tokens excedentes (quando um `max_length` é especificado e `return_overflowing_tokens=True`). - **num_truncated_tokens** -- Número de tokens truncados (quando um `max_length` é especificado e `return_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=True` e `return_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 deslizante (com passo definido pelo usuário) para tokens que excedem o limite. #### save_chat_templates[[transformers.MistralCommonBackend.save_chat_templates]] ```python save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1718) `MistralCommonBackend` não implementa `save_chat_templates` por design, pois `mistral-common` não utiliza chat templates. #### save_pretrained[[transformers.MistralCommonBackend.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike | pathlib.Path, push_to_hub: bool = False, token: str | bool | None = None, commit_message: str | None = None, repo_id: str | None = None, private: bool | None = None, save_format: str | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1552) **Parâmetros:** save_directory (`str | os.PathLike | Path`) : Diretório onde o tokenizer será salvo. push_to_hub (`bool`, *opcional*, padrão `False`) : Enviar para o HF Hub após salvar. token (`str` ou `bool`, *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 do Hub. private (`bool`, *opcional*) : 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 de tokenizer original (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. #### save_vocabulary[[transformers.MistralCommonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1729) `MistralCommonBackend` não implementa `save_vocabulary` por design. Isso ocorre porque `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[[transformers.MistralCommonBackend.tokenize]] ```python tokenize(text: str, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L645) **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`. Gerará um erro se utilizado. **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[[transformers.MistralCommonBackend.truncate_sequences]] ```python truncate_sequences(ids: list, pair_ids: None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L974) **Parâmetros:** ids (`list[int]`) : IDs de entrada tokenizados. Podem ser obtidos a partir de uma string encadeando os métodos `tokenize` e `convert_tokens_to_ids`. pair_ids (`None`, *opcional*) : Não suportado pelo `MistralCommonBackend`. Mantido para corresponder à assinatura de `PreTrainedTokenizerBase.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 (`str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `'longest_first'`) : A estratégia a ser seguida para a truncagem. Pode ser: - `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou 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 truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível pelo modelo). stride (`int`, *opcional*, padrão 0) : Se definido para um número positivo, os tokens em estouro retornados conterã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[[transformers.MixtralModel]] #### transformers.MixtralModel[[transformers.MixtralModel]] ```python transformers.MixtralModel(config: MixtralConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L399) **Parâmetros:** config ([MixtralConfig](/docs/transformers/main/pt/model_doc/mixtral#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.MixtralModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L416) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). **Retorna:** `MoeModelOutputWithPast` ou `tuple(torch.Tensor)` Um `MoeModelOutputWithPast` 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 ([MixtralConfig](/docs/transformers/main/pt/model_doc/mixtral#transformers.MixtralConfig)) e das entradas. O método forward do [MixtralModel](/docs/transformers/main/pt/model_doc/mixtral#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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 nas cabeças de autoatenção. - **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_probs=True` e `config.add_router_probs=True` são passados ou quando `config.output_router_probs=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, sequence_length, num_experts)`. Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts. ## MixtralForCausalLM[[transformers.MixtralForCausalLM]] #### transformers.MixtralForCausalLM[[transformers.MixtralForCausalLM]] ```python transformers.MixtralForCausalLM(config: MixtralConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L544) **Parâmetros:** config ([MixtralConfig](/docs/transformers/main/pt/model_doc/mixtral#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O Modelo Mixtral para modelagem de linguagem causal. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.MixtralForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_router_logits: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L562) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_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ão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_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 um `torch.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.Tensor)` Um `MoeCausalLMOutputWithPast` 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 ([MixtralConfig](/docs/transformers/main/pt/model_doc/mixtral#transformers.MixtralConfig)) e das entradas. O método forward de [MixtralForCausalLM](/docs/transformers/main/pt/model_doc/mixtral#transformers.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 `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de 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.Tensor`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.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) retornam `None` aqui, mas ainda retornam `router_logits`. - **router_logits** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_router_logits=True` é passado ou quando `config.output_router_logits=True`) -- Tupla de `torch.Tensor` (um 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 quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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 nas cabeças de autoatenção. Exemplo: ```python >>> 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[[transformers.MixtralForSequenceClassification]] #### transformers.MixtralForSequenceClassification[[transformers.MixtralForSequenceClassification]] ```python transformers.MixtralForSequenceClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L641) #### forward[[transformers.MixtralForSequenceClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L128) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`Cache`, *opcional*) : hidden-states 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de 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]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_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 `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. ## MixtralForTokenClassification[[transformers.MixtralForTokenClassification]] #### transformers.MixtralForTokenClassification[[transformers.MixtralForTokenClassification]] ```python transformers.MixtralForTokenClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L645) #### forward[[transformers.MixtralForTokenClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`Cache`, *opcional*) : hidden-states 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_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 `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. ## MixtralForQuestionAnswering[[transformers.MixtralForQuestionAnswering]] #### transformers.MixtralForQuestionAnswering[[transformers.MixtralForQuestionAnswering]] ```python transformers.MixtralForQuestionAnswering(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L649) #### forward[[transformers.MixtralForQuestionAnswering.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, start_positions: torch.LongTensor | None = None, end_positions: torch.LongTensor | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L208) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`Cache`, *opcional*) : hidden-states 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. start_positions (`torch.LongTensor` de 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.LongTensor` de 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 `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.