Hugging Face's logo

Transformers documentation

Pixtral

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 publicado no HF papers em 2024-10-09 e contribuído para o Hugging Face Transformers em 2024-09-14.

Pixtral

Pixtral é 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 Pixtral architecture. Taken from the blog post.

Você pode encontrar todos os checkpoints originais do Pixtral na organização Mistral AI.

Este modelo foi contribuído por amyeroberts e ArthurZ. Clique nos modelos Pixtral na barra lateral à direita para ver mais exemplos de como aplicar o Pixtral a diferentes tarefas de visão e linguagem.

AutoModel
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 para mais backends de quantização disponíveis.

O exemplo abaixo usa bitsandbytes para quantizar o modelo em 4 bits.

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 como codificador de visão e MistralForCausalLM para seu decodificador de linguagem.

  • O modelo substitui internamente os placeholders de tokens [IMG] por embeddings de imagem.

    "<s>[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

classe transformers.PixtralVisionConfig

< >

( 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 = Nonehidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu'attention_dropout: float | int = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneinitializer_range: float = 0.02 )

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

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

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.

PixtralVisionModel

classe transformers.PixtralVisionModel

< >

( config: PixtralVisionConfig )

Parâmetros

  • config (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() 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. 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

< >

( pixel_values: Tensorimage_sizes: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

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), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem.

Retorna

BaseModelOutputWithPooling ou tuple(torch.FloatTensor)

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

O método forward do 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 frase (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 (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com formato (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.FloatTensor), opcional, retornado 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 nos cabeçalhos de autoatenção.

PixtralImageProcessor

classe transformers.PixtralImageProcessor

< >

( **kwargs: *<class 'transformers.models.pixtral.image_processing_pixtral.PixtralImageProcessorKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida 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 máximas de entrada 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 a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — 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, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar 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) — 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 o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido 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 recortar a imagem centralmente.
  • 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 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 (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que 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.

pré-processamento

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.pixtral.image_processing_pixtral.PixtralImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

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 passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida 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 a aplicação de 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) — 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 o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido 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 recortar a imagem centralmente.
  • 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 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 (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que 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

classe transformers.PixtralImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.pixtral.image_processing_pil_pixtral.PixtralImageProcessorKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida 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 máximas de entrada 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 a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — 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, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar 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) — 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 o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido 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 recortar a imagem centralmente.
  • 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 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 (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que 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.

pré-processamento

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.pixtral.image_processing_pil_pixtral.PixtralImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

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 passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida 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 a aplicação de 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) — 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 o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido 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 recortar a imagem centralmente.
  • 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 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 (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que 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

classe transformers.PixtralProcessor

< >

( image_processor = Nonetokenizer = Nonepatch_size: int = 16spatial_merge_size: int = 1chat_template = Noneimage_token = '[IMG]'image_break_token = '[IMG_BREAK]'image_end_token = '[IMG_END]'**kwargs )

Parâmetros

  • image_processor (PixtralImageProcessor) — O processador de imagem é 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) — 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 fim 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 oferece todas as funcionalidades de PixtralImageProcessor e MistralCommonBackend. Consulte ~PixtralImageProcessor e ~MistralCommonBackend para mais informações.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )

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 passar 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 pré-tokenizada). Se você passar uma entrada pré-tokenizada, 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 a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se passar 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, opcional) — Se definido, retornará tensors 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, 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.
Update on GitHub

←Pix2Struct PP-DocLayoutV2→