# Mistral 3

[Mistral 3](https://mistral.ai/news/mistral-small-3) é um modelo otimizado para latência, com muito menos camadas para reduzir o tempo de cada passagem direta. Este modelo adiciona compreensão de visão e suporta comprimentos de contexto longos, de até 128K tokens, sem comprometer o desempenho.

Você pode encontrar os checkpoints originais do Mistral 3 na organização [Mistral AI](https://huggingface.co/mistralai/models?search=mistral-small-3).

> [!TIP]
> Este modelo foi contribuído por [cyrilvallez](https://huggingface.co/cyrilvallez) e [yonigozlan](https://huggingface.co/yonigozlan). Clique nos modelos Mistral3 na barra lateral à direita para mais exemplos de como aplicar o Mistral3 a diferentes tarefas.
>
> Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais.

O exemplo abaixo demonstra como gerar texto para uma imagem com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) e a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

pipeline = pipeline(
    task="image-text-to-text",
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    device=0
)
outputs = pipeline(text=messages, max_new_tokens=50, return_full_text=False)

outputs[0]["generated_text"]
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(
    model_checkpoint,
    device_map="auto",
)

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True, return_dict=True,
    return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_new_tokens=20)
decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)

decoded_output
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

## Observações

- O Mistral 3 suporta apenas a geração de texto.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = ".mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

SYSTEM_PROMPT = "You are a conversational agent that always answers straight to the point, always end your accurate response with an ASCII drawing of a cat."
user_prompt = "Give me 5 non-formal ways to say 'See you later' in French."

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": user_prompt},
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=text, return_tensors="pt").to(0)
generate_ids = model.generate(**inputs, max_new_tokens=50, do_sample=False)
decoded_output = processor.batch_decode(generate_ids[:, inputs["input_ids"].shape[1] :], skip_special_tokens=True)[0]

print(decoded_output)
"1. À plus tard!
 2. Salut, à plus!
 3. À toute!
 4. À la prochaine!
 5. Je me casse, à plus!

```

 /\_/\
( o.o )
 > ^ <

```"
````

- O Mistral 3 aceita entradas de imagem e texto em lote.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
                 {"type": "text", "text": "Describe this image"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageCalm waters reflect\nWhispers of the forest's breath\nPeace on wooden path"
, "Describe this imageThe image depicts a vibrant street scene in what appears to be a Chinatown district. The focal point is a traditional Chinese"]
```

- O Mistral 3 também suportava entradas de imagem e texto em lote, com um número diferente de imagens para cada texto. O exemplo abaixo quantiza o modelo com bitsandbytes.

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForImageTextToText.from_pretrained(
     model_checkpoint, quantization_config=quantization_config
 device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                 {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageSure, here is a haiku inspired by the image:\n\nCalm lake's wooden path\nSilent forest stands guard\n", "These images depict two different landmarks. Can you identify them? Certainly! The images depict two iconic landmarks:\n\n1. The first image shows the Statue of Liberty in New York City."]
```

## Mistral3Config[[transformers.Mistral3Config]]

#### transformers.Mistral3Config[[transformers.Mistral3Config]]

```python
transformers.Mistral3Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_index: int = 10, projector_hidden_act: str = 'gelu', vision_feature_layer: int | list[int] = -1, multimodal_projector_bias: bool = False, spatial_merge_size: int = 2, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/configuration_mistral3.py#L26)

**Parâmetros:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

image_token_index (`int`, *opcional*, padrão `10`) : O índice do token de imagem usado como marcador para as imagens de entrada.

projector_hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação usada pelo projetor multimodal.

vision_feature_layer (`Union[int, list[int]]`, *opcional*, padrão `-1`) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.

multimodal_projector_bias (`bool`, *opcional*, padrão `False`) : Se deve usar viés no projetor multimodal.

spatial_merge_size (`int`, *opcional*, padrão `2`) : O tamanho da janela de mesclagem espacial usada para reduzir o número de tokens visuais mesclando patches vizinhos.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

Esta é a classe de configuração para armazenar a configuração de um Mistral3Model. Ela é usada para instanciar um modelo Mistral3 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/Mistral-Small-3.1-24B-Instruct-2503](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)

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 Mistral3ForConditionalGeneration, Mistral3Config, PixtralVisionConfig, MistralConfig

>>> # Initializing a Pixtral-vision config
>>> vision_config = PixtralVisionConfig()

>>> # Initializing a Mistral config
>>> text_config = MistralConfig()

>>> # Initializing a Mistral3 configuration
>>> configuration = Mistral3Config(vision_config, text_config)

>>> # Initializing a model from the mistral3.1 configuration
>>> model = Mistral3ForConditionalGeneration(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("<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](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.

#### create_token_type_ids_from_sequences[[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.

## Mistral3Model[[transformers.Mistral3Model]]

#### transformers.Mistral3Model[[transformers.Mistral3Model]]

```python
transformers.Mistral3Model(config: Mistral3Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L199)

**Parâmetros:**

config ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) : 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 Mistral3, que consiste em um backbone de visão e um modelo de linguagem, sem uma cabeça de modelagem de linguagem.

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.Mistral3Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = 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, vision_feature_layer: int | list[int] | None = None, use_cache: bool | None = None, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L269)

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

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor). Veja [PixtralImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([PixtralProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralProcessor) usa [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) para processar imagens).

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.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.

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

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** `Mistral3ModelOutputWithPast` ou `tuple(torch.Tensor)`

Um `Mistral3ModelOutputWithPast` 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 ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) e das entradas.

O método forward do [Mistral3Model](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Model) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- 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.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.

#### get_image_features[[transformers.Mistral3Model.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L208)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor). Veja [PixtralImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([PixtralProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralProcessor) usa [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) para processar imagens).

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) e das entradas.

Obtém os estados ocultos finais da imagem da torre de visão e aplica a projeção multimodal.

- **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.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **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.

#### get_placeholder_mask[[transformers.Mistral3Model.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, image_features: Tensor)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L245)

Obtém a máscara de placeholder multimodal a partir de `input_ids` ou `inputs_embeds` e verifica se a contagem de tokens de placeholder é igual ao comprimento das características multimodais. Se os comprimentos forem diferentes, um erro é lançado.

## Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

#### transformers.Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

```python
transformers.Mistral3ForConditionalGeneration(config: Mistral3Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L336)

**Parâmetros:**

config ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) : 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 MISTRAL3, que consiste em um backbone de visão e um modelo de linguagem.

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.Mistral3ForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = 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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L366)

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

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor). Veja [PixtralImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([PixtralProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralProcessor) usa [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) para processar imagens).

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

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

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** `Mistral3CausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Um `Mistral3CausalLMOutputWithPast` 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 ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) e das entradas.

O método forward de [Mistral3ForConditionalGeneration](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3ForConditionalGeneration) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, 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).
- **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) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.

Exemplo:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, text=prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is the image?The image depicts two cats lying on a pink blanket."
```

#### get_image_features[[transformers.Mistral3ForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L349)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor). Veja [PixtralImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([PixtralProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralProcessor) usa [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) para processar imagens).

image_sizes (`torch.Tensor` de forma `(batch_size, 2)`) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.

vision_feature_layer (`Union[int, list[int]]`, *opcional*) : O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([Mistral3Config](/docs/transformers/main/pt/model_doc/mistral3#transformers.Mistral3Config)) e das entradas.

- **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.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **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 PIL import Image
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

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

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