# Pixtral [Pixtral](https://huggingface.co/papers/2410.07073) é um modelo multimodal treinado para entender imagens naturais e documentos. Ele aceita imagens em sua resolução e proporção de aspecto naturais, sem redimensionamento ou preenchimento, graças aos seus embeddings 2D RoPE. Além disso, o Pixtral possui uma janela de contexto longa de 128K tokens para processar um grande número de imagens. O Pixtral combina um codificador de visão de 400M com um decodificador Mistral Nemo de 12B. drawing Arquitetura do Pixtral. Retirada do post no blog. Você pode encontrar todos os checkpoints originais do Pixtral na organização [Mistral AI](https://huggingface.co/mistralai/models?search=pixtral). > [!TIP] > Este modelo foi contribuído por [amyeroberts](https://huggingface.co/amyeroberts) e [ArthurZ](https://huggingface.co/ArthurZ). Clique nos modelos Pixtral na barra lateral à direita para mais exemplos de como aplicar o Pixtral a diferentes tarefas de visão e linguagem. ```python import torch from transformers import AutoProcessor, LlavaForConditionalGeneration model_id = "mistral-community/pixtral-12b" model = LlavaForConditionalGeneration.from_pretrained(model_id, device_map="auto") processor = AutoProcessor.from_pretrained(model_id) url_dog = "https://picsum.photos/id/237/200/300" url_mountain = "https://picsum.photos/seed/picsum/200/300" chat = [ { "role": "user", "content": [ {"type": "text", "content": "Can this animal"}, {"type": "image", "url": url_dog}, {"type": "text", "content": "live here?"}, {"type": "image", "url" : url_mountain} ] } ] inputs = processor.apply_chat_template(chat, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device) generate_ids = model.generate(**inputs, max_new_tokens=500) output = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] ``` A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de [Quantização](../quantization/overview) para mais backends de quantização disponíveis. O exemplo abaixo usa [bitsandbytes](../quantization/bitsandbytes) para quantizar o modelo em 4 bits. ```python import requests import torch from PIL import Image from transformers import AutoProcessor, BitsAndBytesConfig, LlavaForConditionalGeneration model_id = "mistral-community/pixtral-12b" quantization_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16 ) model = LlavaForConditionalGeneration.from_pretrained( model_id, quantization_config=quantization_config, device_map="auto" ) processor = AutoProcessor.from_pretrained(model_id) dog_url = "https://picsum.photos/id/237/200/300" mountain_url = "https://picsum.photos/seed/picsum/200/300" dog_image = Image.open(requests.get(dog_url, stream=True).raw) mountain_image = Image.open(requests.get(mountain_url, stream=True).raw) chat = [ { "role": "user", "content": [ {"type": "text", "text": "Can this animal"}, {"type": "image"}, {"type": "text", "text": "live here?"}, {"type": "image"} ] } ] prompt = processor.apply_chat_template(chat, tokenize=False, add_generation_prompt=True) inputs = processor(text=prompt, images=[dog_image, mountain_image], return_tensors="pt").to(model.device) inputs["pixel_values"] = inputs["pixel_values"].to(model.dtype) inputs = {k: v.to(model.device) for k, v in inputs.items()} generate_ids = model.generate(**inputs, max_new_tokens=100) output = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False) print(output) ``` ## Observações - O Pixtral usa [PixtralVisionModel](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralVisionModel) como codificador de visão e [MistralForCausalLM](/docs/transformers/main/pt/model_doc/mistral#transformers.MistralForCausalLM) para seu decodificador de linguagem. - O modelo substitui internamente os placeholders de tokens `[IMG]` por embeddings de imagem. ```py "[INST][IMG]\nWhat are the things I should be cautious about when I visit this place?[/INST]" ``` Os tokens `[IMG]` são substituídos por um número de tokens `[IMG]` que depende da altura e da largura de cada imagem. Cada linha da imagem é separada por um token `[IMG_BREAK]` e cada imagem é separada por um token `[IMG_END]`. Use o método `~Processor.apply_chat_template` para lidar com esses tokens por você. ## PixtralVisionConfig[[transformers.PixtralVisionConfig]] #### transformers.PixtralVisionConfig[[transformers.PixtralVisionConfig]] ```python transformers.PixtralVisionConfig(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, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 24, num_attention_heads: int = 16, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu', attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/configuration_pixtral.py#L24) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `24`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `1024`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. Esta é a classe de configuração para armazenar a configuração de um PixtralVisionModel. Ela é usada para instanciar um modelo Pixtral 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 [mistral-labs/pixtral-12b](https://huggingface.co/mistral-labs/pixtral-12b) 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 PixtralVisionModel, PixtralVisionConfig >>> # Initializing a Pixtral-12B style configuration >>> config = PixtralVisionConfig() >>> # Initializing a model (with randomly initialized weights) from the configuration >>> model = PixtralVisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MistralCommonBackend[[transformers.MistralCommonBackend]] #### transformers.MistralCommonBackend[[transformers.MistralCommonBackend]] ```python transformers.MistralCommonBackend(tokenizer_path: str | os.PathLike | pathlib.Path, mode: str | ValidationMode = 'test', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L194) Classe para encapsular tokenizadores do `mistral-common`. `mistral-common` é a biblioteca oficial de tokenização para os modelos da Mistral AI. Para usá-la, você precisa instalá-la com: ```bash pip install transformers[mistral-common] ``` Caso contrário, o tokenizer recorre à implementação do tokenizer da Transformers. Para mais informações sobre `mistral-common`, consulte [mistral-common](https://github.com/mistralai/mistral-common). Esta classe é um wrapper em torno de um `mistral_common.tokens.tokenizers.mistral.MistralTokenizer`. Ela fornece uma interface compatível com o Hugging Face para tokenizar usando o tokenizador oficial mistral-common e herda da classe `PreTrainedTokenizerBase`. Aqui estão as principais diferenças de comportamento em relação à classe `PythonBackend`: - Pares de sequências não são suportados. A assinatura foi mantida por compatibilidade, mas todos os argumentos relacionados a pares de sequências são ignorados. Os valores de retorno para pares são retornados como `None`. - O argumento `is_split_into_words` não é suportado. - Não é possível adicionar novos tokens ao tokenizer. Os tokens especiais são tratados de forma diferente em Transformers. Em `mistral-common`, os tokens especiais nunca são codificados diretamente. Isso significa que: `tokenizer.encode("")` não retornará o ID do token ``. Em vez disso, retornará uma lista de IDs correspondente à tokenização da string `""`. Para mais informações, consulte a [documentação do mistral-common](https://mistralai.github.io/mistral-common/usage/tokenizers/#special-tokens). Se você tiver sugestões para melhorar esta classe, abra uma issue no [repositório GitHub mistral-common](https://github.com/mistralai/mistral-common/issues) se estiver relacionada ao tokenizer ou no [repositório GitHub Transformers](https://github.com/huggingface/transformers/issues) se estiver relacionada à interface do Hugging Face. #### add_special_tokens[[transformers.MistralCommonBackend.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1679) `MistralCommonBackend` não implementa `add_special_tokens` por design. Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios `Transformers` ou `mistral-common` para solicitá-lo. #### add_tokens[[transformers.MistralCommonBackend.add_tokens]] ```python add_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1691) `MistralCommonBackend` não implementa `add_special_tokens` por design. Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios `Transformers` ou `mistral-common` para solicitá-lo. #### apply_chat_template[[transformers.MistralCommonBackend.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | collections.abc.Callable] | None = None, add_generation_prompt: bool = False, continue_final_message: bool = False, tokenize: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_dict: bool = True, reasoning_effort: ReasoningEffort | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1038) **Parâmetros:** conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) : Uma lista de dicionários com as chaves "role" e "content", representando o histórico do chat até o momento. tools (`List[Union[Dict, Callable]]`, *opcional*) : Uma lista de ferramentas (funções chamáveis) que estarão acessíveis ao modelo. Se o template não suportar chamadas de função, este argumento não terá efeito. Cada ferramenta deve ser passada como um JSON Schema, fornecendo o nome, a descrição e os tipos de argumentos da ferramenta. Consulte nosso [guia de chat templating](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) para mais informações. add_generation_prompt (`bool`, *opcional*) : Este argumento é um no-op para `MistralCommonBackend`. No entanto, ele não pode ser usado ao mesmo tempo que `continue_final_message` para manter a API consistente. Se qualquer conversa terminar com uma mensagem do assistente, será gerado um erro. Nesses casos, use `continue_final_message` em vez disso. continue_final_message (bool, *opcional*) : Se definido, o chat será formatado de modo que a mensagem final no chat seja aberta, sem tokens EOS. O modelo continuará essa mensagem em vez de iniciar uma nova. Isso permite "preencher" parte da resposta do modelo. Não pode ser usado ao mesmo tempo que `add_generation_prompt`. tokenize (`bool`, padrão `True`) : Se deve tokenizar a saída. Se `False`, a saída será uma string. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre: - `True` ou `'longest'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode retornar um lote com sequências de comprimentos diferentes). truncation (`bool`, padrão `False`) : Se as sequências devem ser truncadas no comprimento máximo. Não tem efeito se tokenize for `False`. max_length (`int`, *opcional*) : Comprimento máximo (em tokens) a ser usado para preenchimento ou truncamento. Não tem efeito se tokenize for `False`. Se não for especificado, o atributo `max_length` do tokenizer será usado como padrão. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Não tem efeito se tokenize for `False`. Valores aceitáveis são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. return_dict (`bool`, padrão `False`) : Se deve retornar um dicionário com saídas nomeadas. Não tem efeito se tokenize for `False`. Se pelo menos uma conversa contiver uma imagem, seus valores de pixel serão retornados na chave `pixel_values` e os tamanhos das imagens na chave `image_sizes`. reasoning_effort (`ReasoningEffort`, *opcional*) : O esforço de raciocínio a ser usado para a conclusão do chat em modelos que o suportam. Os valores possíveis são: - `ReasoningEffort.none`: O modelo não realizará raciocínio. - `ReasoningEffort.high`: O modelo usará uma abordagem de raciocínio. Se não for especificado, o esforço de raciocínio padrão será utilizado. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Argumentos adicionais passados para o método `ChatCompletionRequest.from_openai` do mistral-common. **Retorna:** `Union[str, list[int], list[str], list[list[int]], BatchEncoding]` O chat tokenizado até o momento, incluindo os tokens de controle. Esta saída está pronta para ser passada ao modelo, seja diretamente ou por meio de métodos como `generate()`. Converte uma lista de dicionários com as chaves `"role"` e `"content"` em uma lista de ids de tokens. #### batch_decode[[transformers.MistralCommonBackend.batch_decode]] ```python batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L512) **Parâmetros:** sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Lista de ids de entrada tokenizados. Pode ser obtido usando o método `__call__`. skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação. clean_up_tokenization_spaces (`bool`, *opcional*) : Se deve ou não limpar os espaços de tokenização. Se `None`, o padrão será `self.clean_up_tokenization_spaces`. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Não suportado por `MistralCommonBackend.batch_decode`. Gerará um erro se utilizado. **Retorna:** `list[str]` A lista de frases decodificadas. Converta uma lista de listas de ids de tokens em uma lista de strings chamando decode. Este método é fornecido para compatibilidade reversa. O método `decode` agora processa entradas em lote nativamente, portanto, você pode usar `decode` diretamente em vez de `batch_decode`. #### build_inputs_with_special_tokens[[transformers.MistralCommonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1284) **Parâmetros:** token_ids_0 (`list[int]`) : Lista de IDs aos quais os tokens especiais serão adicionados. token_ids_1 (`None`, *opcional*) : None, mantido para corresponder à assinatura do Transformers. **Retorna:** `list[int]` Lista de IDs de entrada com os tokens especiais apropriados. Construa as entradas do modelo a partir de uma sequência adicionando tokens especiais. Este método constrói dinamicamente as entradas com base no `mode` do tokenizer: - `"test"`: seq0 [EOS] - `"finetuning"`: [BOS] seq0 #### convert_added_tokens[[transformers.MistralCommonBackend.convert_added_tokens]] ```python convert_added_tokens(obj: tokenizers.AddedToken | typing.Any, save: bool = False, add_type_field: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1704) `MistralCommonBackend` não implementa `convert_added_tokens` por design. Se você deseja que esse comportamento seja implementado, abra uma issue nos repositórios `Transformers` ou `mistral-common` para solicitá-lo. #### 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. ## PixtralVisionModel[[transformers.PixtralVisionModel]] #### transformers.PixtralVisionModel[[transformers.PixtralVisionModel]] ```python transformers.PixtralVisionModel(config: PixtralVisionConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/modeling_pixtral.py#L379) **Parâmetros:** config ([PixtralVisionConfig](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralVisionConfig)) : 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 Pixtral puro, que gera estados ocultos brutos sem nenhum head específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.PixtralVisionModel.forward]] ```python forward(pixel_values: Tensor, image_sizes: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/modeling_pixtral.py#L402) **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)`, *opcional*) : Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.FloatTensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([PixtralVisionConfig](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralVisionConfig)) e das entradas. O método forward do [PixtralVisionModel](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralVisionModel) 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.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.FloatTensor` 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 sentença (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## PixtralImageProcessor[[transformers.PixtralImageProcessor]] #### transformers.PixtralImageProcessor[[transformers.PixtralImageProcessor]] ```python transformers.PixtralImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pixtral.py#L99) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'longest_edge' : 1024}`): Descreve as dimensões de entrada máximas para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.48145466, 0.4578275, 0.40821073]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.26862954, 0.26130258, 0.27577711]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. patch_size (`Union[dict[str, *kwargs*, int], int]` *opcional*, padrão `{"height" : 16, "width": 16}`): Tamanho dos patches no modelo, usado para calcular o tamanho da imagem de saída. Constrói um processador de imagem PixtralImageProcessor. #### preprocess[[transformers.PixtralImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pixtral.py#L118) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. patch_size (`Union[dict[str, *kwargs*, int], int]` *opcional*, padrão `{"height" : 16, "width": 16}`): Tamanho dos patches no modelo, usado para calcular o tamanho da imagem de saída. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. ## PixtralImageProcessorPil[[transformers.PixtralImageProcessorPil]] #### transformers.PixtralImageProcessorPil[[transformers.PixtralImageProcessorPil]] ```python transformers.PixtralImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pil_pixtral.py#L107) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'longest_edge' : 1024}`): Descreve as dimensões de entrada máximas para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.48145466, 0.4578275, 0.40821073]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.26862954, 0.26130258, 0.27577711]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. patch_size (`Union[dict[str, *kwargs*, int], int]` *opcional*, padrão `{"height" : 16, "width": 16}`): Tamanho dos patches no modelo, usado para calcular o tamanho da imagem de saída. Constrói um processador de imagem PixtralImageProcessor. #### preprocess[[transformers.PixtralImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pil_pixtral.py#L126) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. patch_size (`Union[dict[str, *kwargs*, int], int]` *opcional*, padrão `{"height" : 16, "width": 16}`): Tamanho dos patches no modelo, usado para calcular o tamanho da imagem de saída. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. ## PixtralProcessor[[transformers.PixtralProcessor]] #### transformers.PixtralProcessor[[transformers.PixtralProcessor]] ```python transformers.PixtralProcessor(image_processor = None, tokenizer = None, patch_size: int = 16, spatial_merge_size: int = 1, chat_template = None, image_token = '[IMG]', image_break_token = '[IMG_BREAK]', image_end_token = '[IMG_END]', **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/processing_pixtral.py#L50) **Parâmetros:** image_processor (`PixtralImageProcessor`) : O processador de imagens é uma entrada obrigatória. tokenizer (`MistralCommonBackend`) : O tokenizer é uma entrada obrigatória. patch_size (`int`, *opcional*, padrão 16) : Tamanho do patch da torre de visão. spatial_merge_size (`int`, *opcional*, padrão 1) : O fator de redução de amostragem para a operação de mesclagem espacial. chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. image_token (`str`, *opcional*, padrão `"[IMG]"`) : Token especial usado para indicar a localização da imagem. image_break_token (`str`, *opcional*, padrão `"[IMG_BREAK]"`) : Token especial usado para indicar o final de uma linha de pixels em uma imagem. image_end_token (`str`, *opcional*, padrão `"[IMG_END]"`) : Token especial usado para indicar o fim de uma entrada de imagem. Constrói um PixtralProcessor que encapsula um processador de imagem e um tokenizer em um único processador. [PixtralProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralProcessor) oferece todas as funcionalidades de [PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) e [MistralCommonBackend](/docs/transformers/main/pt/model_doc/mistral#transformers.MistralCommonBackend). Consulte [~PixtralImageProcessor](/docs/transformers/main/pt/model_doc/pixtral#transformers.PixtralImageProcessor) e [~MistralCommonBackend](/docs/transformers/main/pt/model_doc/mistral#transformers.MistralCommonBackend) para mais informações. #### __call__[[transformers.PixtralProcessor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L657) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.