Hugging Face's logo

Transformers documentation

Mistral 3

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 18/03/2025.

PyTorch

Mistral 3

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

Este modelo foi contribuído por cyrilvallez e yonigozlan. Clique nos modelos Mistral3 na barra lateral à direita para ver mais exemplos de como aplicar o Mistral3 a diferentes tarefas.

Defina use_kernels=True em from_pretrained() para substituir camadas compatíveis por kernels otimizados do Hub. Consulte Carregando kernels para saber mais.

O exemplo abaixo demonstra como gerar texto para uma imagem com Pipeline e a classe AutoModel.

Pipeline
AutoModel
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'

Observações

  • O Mistral 3 suporta apenas a geração de texto.
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.
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.
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

classe transformers.Mistral3Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 10projector_hidden_act: str = 'gelu'vision_feature_layer: int | list[int] = -1multimodal_projector_bias: bool = Falsespatial_merge_size: int = 2tie_word_embeddings: bool = True )

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 de posição 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 ao mesclar 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import 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

classe transformers.MistralCommonBackend

< >

( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )

Classe para encapsular tokenizadores do mistral-common.

mistral-common é a biblioteca oficial de tokenização para os modelos da Mistral AI. Para usá-la, você precisa instalá-la com:

pip install transformers[mistral-common]

Caso contrário, o tokenizer recorre à implementação do tokenizer da Transformers.

Para mais informações sobre mistral-common, consulte mistral-common.

Esta classe é um wrapper em torno de um mistral_common.tokens.tokenizers.mistral.MistralTokenizer. Ela fornece uma interface compatível com o Hugging Face para tokenizar usando o tokenizador oficial mistral-common e herda da classe PreTrainedTokenizerBase.

Aqui estão as principais diferenças de comportamento em relação à classe PythonBackend:

  • Pares de sequências não são suportados. A assinatura foi mantida por compatibilidade, mas todos os argumentos relacionados a pares de sequências são ignorados. Os valores de retorno para pares são retornados como None.
  • O argumento is_split_into_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.

Se você tiver sugestões para melhorar esta classe, abra uma issue no repositório GitHub mistral-common se estiver relacionada ao tokenizer ou no repositório GitHub Transformers se estiver relacionada à interface do Hugging Face.

add_special_tokens

< >

( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )

MistralCommonBackend não implementa add_special_tokens por design.

Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.

add_tokens

< >

( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )

MistralCommonBackend não implementa add_special_tokens por design.

Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.

apply_chat_template

< >

( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]

Parâmetros

  • conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — Uma lista de dicts com as chaves “role” e “content”, representando o histórico do chat até o momento.
  • tools (List[Union[Dict, Callable]], opcional) — Uma lista de ferramentas (funções chamáveis) que estarão acessíveis ao modelo. Se o template não suportar function calling, este argumento não terá efeito. Cada ferramenta deve ser passada como um JSON Schema, fornecendo o nome, a descrição e os tipos de argumentos da ferramenta. Consulte nosso guia de chat templating para mais informações.
  • add_generation_prompt (bool, opcional) — Este argumento é um no-op para MistralCommonBackend. No entanto, ele não pode ser usado ao mesmo tempo que continue_final_message para manter a API consistente. Se alguma 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 do chat seja aberta, sem tokens EOS. O modelo continuará essa mensagem em vez de iniciar uma nova. Isso permite “preencher” parte da resposta do modelo. Não pode ser usado ao mesmo tempo que add_generation_prompt.
  • tokenize (bool, padrão True) — Se deve tokenizar a saída. Se False, a saída será uma string.
  • padding (bool, str ou 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': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o 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, 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 padding 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, opcional) — Se definido, retornará tensors de um framework específico. Não tem efeito se tokenize for False. Valores aceitos:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
  • return_dict (bool, padrão False) — Indica 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 utilizará uma abordagem de raciocínio. Se não for especificado, o esforço de raciocínio padrão será utilizado.
  • kwargs (argumentos de palavra-chave adicionais, opcional) — Argumentos adicionais passados para o método ChatCompletionRequest.from_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

< >

( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]

Parâmetros

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Lista de ids de entrada tokenizados. Pode ser obtida usando o método __call__.
  • skip_special_tokens (bool, opcional, padrão False) — Indica se os tokens especiais devem ser removidos durante a decodificação.
  • clean_up_tokenization_spaces (bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se for None, o valor padrão será self.clean_up_tokenization_spaces.
  • kwargs (argumentos de palavra-chave adicionais, opcional) — Não é suportado por MistralCommonBackend.batch_decode. Acionará um erro se for usado.

Retorna

list[str]

A lista de frases decodificadas.

Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode.

Este método é fornecido para compatibilidade reversa. O método decode agora processa entradas em lote nativamente, então você pode usar decode diretamente em vez de batch_decode.

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: None = None ) → list[int]

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

< >

( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )

MistralCommonBackend não implementa convert_added_tokens por design.

Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios Transformers ou mistral-common para solicitá-lo.

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: None = None ) → list[int]

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

< >

( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]

Parâmetros

  • token_ids (Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Uma única sequência ou um lote (lista de sequências) de ids de entrada tokenizados. Pode ser obtido usando o método __call__.
  • skip_special_tokens (bool, opcional, padrão False) — Indica se os tokens especiais devem ser removidos durante a decodificação.
  • clean_up_tokenization_spaces (bool, opcional) — Indica se os espaços de tokenização devem ser limpos. Se for None, o valor padrão será self.clean_up_tokenization_spaces.
  • kwargs (argumentos de palavra-chave adicionais, opcional) — Não é suportado por MistralCommonBackend.decode. Acionará um erro se for usado.

Retorna

Union[str, list[str]]

A string decodificada para uma única sequência, ou uma lista de strings decodificadas para um lote de sequências.

Converte uma sequência de ids em uma string, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização.

encode

< >

( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor

Parâmetros

  • text (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) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza 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ê deseja adicionar tokens bos ou eos automaticamente. 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, 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 preenchimento 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, 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 truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
  • max_length (int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.

    Se não for definido ou for definido como None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

  • stride (int, opcional, padrão 0) — Se definido como um número junto 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 truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos.
  • pad_to_multiple_of (int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige 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 o 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, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
  • **kwargs — Não suportado por MistralCommonBackend.encode. Acionará um erro se for usado.

Retorna

list[int], torch.Tensor

Os ids tokenizados do texto.

Converte uma string em uma sequência de ids (inteiros), usando o tokenizer e o vocabulário.

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )

Parâmetros

  • pretrained_model_name_or_path (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, por exemplo, ./my_model_directory/.
  • mode (Union[str, ValidationMode], opcional, padrão é ValidationMode.test) — Modo de validação para o MistralTokenizer tokenizer. Os valores possíveis são:
    • "finetuning" ou ValidationMode.finetuning: o modo de ajuste fino.
    • "test" ou ValidationMode.test: o modo de teste. Ele altera a forma como o tokenizer valida a entrada e prepara a solicitação ao 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) — 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 de bearer HTTP 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, de modo que 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, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

  • padding_side (str, opcional, padrão "left") — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome.
  • truncation_side (str, opcional, padrão "right") — O lado em que o modelo deve ter a truncagem aplicada. Deve ser selecionado entre [‘right’, ‘left’].
  • model_input_names (List[str], opcional) — A lista de entradas aceitas pela passagem direta do modelo (como "token_type_ids" ou "attention_mask"). O valor padrão é obtido do atributo de classe com o mesmo nome.
  • clean_up_tokenization_spaces (bool, opcional, padrã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. Acionará um erro se for usado.

Instancie um MistralCommonBackend a partir de um tokenizer predefinido.

get_chat_template

< >

( chat_template: str | None = Nonetools: list[dict] | None = None )

MistralCommonBackend não implementa get_chat_template por design, pois mistral-common não utiliza modelos de chat.

get_special_tokens_mask

< >

( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

Parâmetros

  • token_ids_0 (list[int]) — Lista de ids da sequência.
  • token_ids_1 (None, opcional) — None, mantido para corresponder à implementação do Transformers.
  • already_has_special_tokens (bool, opcional, padrã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

< >

( ) → Dict[str, int]

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 token que decodificam para a mesma string, devido a sequências parciais de bytes UTF-8 sendo convertidas em �.

num_special_tokens_to_add

< >

( pair: typing.Literal[False] = False ) → int

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

< >

( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding

Parâmetros

  • ids (list[int]) — IDs de entrada tokenizados da primeira sequência.
  • pair_ids (None, opcional) — Não é suportado pelo MistralCommonBackend. Mantido para corresponder à interface do PreTrainedTokenizerBase.
  • add_special_tokens (bool, opcional, padrão True) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza 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ê deseja adicionar tokens bos ou eos automaticamente. 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, 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 preenchimento 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, 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 truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
  • max_length (int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.

    Se não for definido ou for definido como None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

  • stride (int, opcional, padrão 0) — Se definido como um número junto 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 truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos.
  • pad_to_multiple_of (int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige 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 o 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, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos 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 ele retorna uma lista de zeros com o comprimento da sequência, pois apenas uma sequência é suportada.

    O que são IDs de tipo de token?

  • return_attention_mask (bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo return_outputs .

    O que são máscaras de atenção?

  • return_overflowing_tokens (bool, opcional, padrão False) — Indica se as sequências de tokens excedentes devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido 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) — Indica se a máscara de tokens especiais deve ser retornada.
  • 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

Um 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?

  • 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?

  • 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 móvel (com passo definido pelo usuário) para tokens que excedem o limite.

save_chat_templates

< >

( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )

MistralCommonBackend não implementa save_chat_templates por design, pois mistral-common não utiliza chat templates.

save_pretrained

< >

( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]

Parâmetros

  • save_directory (str | os.PathLike | Path) — Diretório onde o tokenizer será salvo.
  • push_to_hub (bool, opcional, padrão False) — Envia 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 no Hub.
  • private (bool, opcional) — Indica se o repositório é privado.
  • save_format (str, opcional) — "mistral" para salvar no formato nativo tekken, "hf" para o formato HuggingFace. None preserva o formato original.
  • kwargs (dict, opcional) — Não suportado — lançará um erro.

Retorna

tuple[str, ...]

Caminhos dos arquivos salvos.

Salve o estado completo do tokenizer.

Quando save_format é "mistral" (ou None para um tokenizer tekken), o arquivo original do tokenizer (por exemplo, tekken.json) é gravado em save_directory. Quando save_format é "hf", os arquivos em formato HF (tokenizer.json + tokenizer_config.json) são gerados em vez disso.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

MistralCommonBackend não implementa save_vocabulary por design.

Isso ocorre porque o mistral-common é configurado por um único arquivo de tokenizer. Se você deseja salvar o vocabulário, considere usar o método save_pretrained em vez disso.

tokenize

< >

( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]

Parâmetros

  • text (str) — A sequência a ser codificada.
  • return_offsets_mapping (Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers.
  • split_special_tokens (Literal[False], opcional) — False, mantido para corresponder à assinatura do Transformers.
  • **kwargs (argumentos de palavra-chave adicionais) — Não suportado por MistralCommonBackend.tokenize. Acionará um erro se for usado.

Retorna

list[str]

A lista de tokens.

Converte uma string em uma sequência de tokens, usando o tokenizer.

Divida em palavras para vocabulários baseados em palavras ou em subpalavras para vocabulários baseados em subpalavras.

truncate_sequences

< >

( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]

Parâmetros

  • ids (list[int]) — IDs de entrada tokenizados. Podem ser obtidos a partir de uma string encadeando os mé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, opcional, padrão é 'longest_first') — A estratégia a ser seguida para a truncagem. Pode ser:
    • 'longest_first': Trunca para o comprimento máximo especificado com o 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 truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceito pelo modelo).
  • stride (int, opcional, padrão 0) — Se definido como um número positivo, os tokens de estouro retornados incluirão alguns tokens da sequência principal retornada. O valor deste argumento define o número de tokens adicionais.

Retorna

Tuple[list[int], None, list[int]]

Os ids truncados e a lista de tokens que excedem o limite. None é retornado para corresponder à assinatura do Transformers.

Trunca um par de sequências no local, seguindo a estratégia.

Mistral3Model

classe transformers.Mistral3Model

< >

( config: Mistral3Config )

Parâmetros

  • config (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() 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. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Noneuse_cache: bool | None = Noneimage_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Mistral3ModelOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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. Consulte PixtralImageProcessor.call() para mais detalhes (PixtralProcessor usa 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

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

Uma 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) e das entradas.

O método forward do 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.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 forma (batch_size, num_heads, sequence_length, sequence_length).

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

  • 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

< >

( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

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. Consulte PixtralImageProcessor.call() para obter detalhes (PixtralProcessor usa 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 ou tuple(torch.Tensor)

Um 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) 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 através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de 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) 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 forma (batch_size, num_heads, sequence_length, sequence_length).

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

get_placeholder_mask

< >

( input_ids: LongTensorinputs_embeds: Tensorimage_features: Tensor )

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 dos recursos multimodais. Se os comprimentos forem diferentes, um erro é lançado.

Mistral3ForConditionalGeneration

classe transformers.Mistral3ForConditionalGeneration

< >

( config: Mistral3Config )

Parâmetros

  • config (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() 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. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Mistral3CausalLMOutputWithPast or tuple(torch.Tensor)

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 padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • 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. Consulte PixtralImageProcessor.call() para mais detalhes (PixtralProcessor usa 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?

  • 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?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • 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 o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring 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 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) e das entradas.

O método forward de 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) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple[torch.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 forma (batch_size, num_heads, sequence_length, sequence_length).

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

  • 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:

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

< >

( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

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. Consulte PixtralImageProcessor.call() para obter detalhes (PixtralProcessor usa 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 ou tuple(torch.Tensor)

Um 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) 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 através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de 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) 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 forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> from 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]
Update on GitHub

←Mistral Large 4 Mistral4→