# Utilitários para tokenizadores Esta página lista todas as funções utilitárias usadas pelos tokenizadores, principalmente a classe [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), que implementa os métodos comuns entre [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend) e [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend). A maioria delas só é útil se você estiver estudando o código dos tokenizadores na biblioteca. ## PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]] #### transformers.PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]] ```python transformers.PreTrainedTokenizerBase(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L968) **Parâmetros:** model_max_length (`int`, *opcional*) : O comprimento máximo (em número de tokens) para as entradas do modelo transformer. Quando o tokenizer é carregado com [from_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), esse valor será definido com o valor armazenado para o modelo associado em `max_model_input_sizes` (veja acima). Se nenhum valor for fornecido, o padrão será VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *opcional*) : O lado em que o modelo deve ter a truncagem aplicada. Deve ser selecionado entre ['right', 'left']. O valor padrão é obtido do atributo de classe com o mesmo nome. chat_template (`str`, *opcional*) : Uma string de modelo Jinja que será usada para formatar listas de mensagens de chat. Consulte https://huggingface.co/docs/transformers/chat_templating para uma descrição completa. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial que representa o início de uma sentença. eos_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial que representa o fim de uma sentença. unk_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial que representa um token fora do vocabulário. sep_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial que separa duas frases diferentes na mesma entrada (usado, por exemplo, pelo BERT). pad_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial usado para tornar os arrays de tokens do mesmo tamanho para fins de loteamento. Em seguida, será ignorado pelos mecanismos de atenção ou pelo cálculo da perda. cls_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial que representa a classe da entrada (usado, por exemplo, pelo BERT). mask_token (`str` ou `tokenizers.AddedToken`, *opcional*) : Um token especial representando um token mascarado (usado em objetivos de pré-treino de modelagem de linguagem mascarada, como o BERT). Será associado a `self.mask_token` e `self.mask_token_id`. extra_special_tokens (lista de `str` ou `tokenizers.AddedToken`, *opcional*) : Uma lista de tokens especiais adicionais específicos do modelo. Adicione-os aqui para garantir que sejam ignorados durante a decodificação quando `skip_special_tokens` estiver definido como True. Se não fizerem parte do vocabulário, serão adicionados ao final do vocabulário. split_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser divididos durante o processo de tokenização. A passagem de um valor afetará o estado interno do tokenizer. O comportamento padrão é não dividir tokens especiais. Isso significa que, se `` for o `bos_token`, então `tokenizer.tokenize("") = ['`]. Caso contrário, se `split_special_tokens=True`, então `tokenizer.tokenize("")` retornará `['<','s', '>']`. Classe base para todos os backends de tokenizers. Atributos de classe (substituídos por classes derivadas) - **vocab_files_names** (`dict[str, str]`) -- Um dicionário que, como chaves, contém o nome da palavra-chave de `__init__` de cada arquivo de vocabulário necessário pelo modelo e, como valores associados, o nome do arquivo para salvar o arquivo correspondente (string). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Um dicionário de dicionários, em que as chaves de alto nível correspondem ao nome da palavra-chave de `__init__` de cada arquivo de vocabulário exigido pelo modelo, e as chaves de baixo nível correspondem aos `short-cut-names` dos modelos pré-treinados, tendo como valores associados a `url` do arquivo de vocabulário pré-treinado correspondente. - **model_input_names** (`list[str]`) -- Uma lista de entradas esperadas na passagem direta do modelo. - **padding_side** (`str`) -- O valor padrão para o lado em que o modelo deve ter padding aplicado. Deve ser `'right'` ou `'left'`. - **truncation_side** (`str`) -- O valor padrão para o lado em que o modelo deve ter a truncagem aplicada. Deve ser `'right'` ou `'left'`. #### __call__[[transformers.PreTrainedTokenizerBase.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | 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_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449) **Parâmetros:** text (`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 as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências). text_pair (`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 as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências). text_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências). text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir `is_split_into_words=True` (para eliminar a ambiguidade com um lote de sequências). tokenizer_kwargs (`dict[str, Any]`, *opcional*) : Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência. 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 automaticamente tokens `bos` ou `eos`. 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 de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for 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 do 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. is_split_into_words (`bool`, *opcional*, padrão `False`) : Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como `True`, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokenizará. Isso é útil para NER ou classificação de tokens. 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. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy. return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [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_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`. 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. - ****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) - **token_type_ids** -- Lista de ids de tipo de token a serem fornecidos a um modelo (quando `return_token_type_ids=True` ou se *"token_type_ids"* estiver em `self.model_input_names`). [O que são IDs de tipo de token?](../glossary#token-type-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`) Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo. #### add_special_tokens[[transformers.PreTrainedTokenizerBase.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict[str, str | AddedToken | Sequence[str | AddedToken]], replace_extra_special_tokens = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1113) **Parâmetros:** special_tokens_dict (dicionário de *str* para *str*, `tokenizers.AddedToken` ou `Sequence[Union[str, AddedToken]]`) : As chaves devem estar na lista de atributos especiais predefinidos: [`bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`]. Os tokens são adicionados apenas se não estiverem já no vocabulário (verificado ao testar se o tokenizer atribui a eles o índice do `unk_token`). replace_extra_special_tokens (`bool`, *opcional*, padrão `True`) : Se `True`, a lista existente de tokens especiais extras será substituída pela lista fornecida em `special_tokens_dict`. Caso contrário, `extra_special_tokens` será estendida. No primeiro caso, os tokens NÃO serão removidos do vocabulário completo do tokenizer - eles apenas serão marcados como tokens não especiais. Lembre-se, isso afeta apenas quais tokens são ignorados durante a decodificação, e não o `added_tokens_encoder` e o `added_tokens_decoder`. Isso significa que os `extra_special_tokens` anteriores ainda são tokens adicionados e não serão divididos pelo modelo. **Retorna:** `int` Número de tokens adicionados ao vocabulário. Adiciona um dicionário de tokens especiais (eos, pad, cls, etc.) ao encoder e os vincula a atributos de classe. Se os tokens especiais NÃO estiverem no vocabulário, eles são adicionados a ele (indexados a partir do último índice do vocabulário atual). Ao adicionar novos tokens ao vocabulário, você deve se certificar de redimensionar também a matriz de incorporação de tokens do modelo, para que sua matriz de incorporação corresponda ao tokenizador. Para fazer isso, use o método [resize_token_embeddings()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings). Usar `add_special_tokens` garante que seus tokens especiais possam ser usados de várias formas: - Tokens especiais podem ser ignorados durante a decodificação usando `skip_special_tokens = True`. - Tokens especiais são cuidadosamente tratados pelo tokenizer (nunca são divididos), de forma semelhante a `AddedTokens`. - Você pode se referir facilmente a tokens especiais usando atributos da classe tokenizer, como `tokenizer.cls_token`. Isso facilita o desenvolvimento de scripts de treinamento e ajuste fino agnósticos ao modelo. Quando possível, os tokens especiais já estão registrados para os modelos pré-treinados fornecidos (por exemplo, o `cls_token` do [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) já está registrado como `'[CLS]'` e o do XLM também está registrado como `''`). Exemplos: ```python # Let's see how to add a new classification token to GPT-2 tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2") model = GPT2Model.from_pretrained("openai-community/gpt2") special_tokens_dict = {"cls_token": ""} num_added_toks = tokenizer.add_special_tokens(special_tokens_dict) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) assert tokenizer.cls_token == "" ``` #### add_tokens[[transformers.PreTrainedTokenizerBase.add_tokens]] ```python add_tokens(new_tokens: str | AddedToken | Sequence[str | AddedToken], special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1218) **Parâmetros:** new_tokens (`str`, `tokenizers.AddedToken` ou uma sequência de *str* ou `tokenizers.AddedToken`) : Os tokens são adicionados apenas se ainda não estiverem no vocabulário. `tokenizers.AddedToken` encapsula um token de string para permitir personalizar seu comportamento: se esse token deve corresponder apenas a uma única palavra, se deve remover todos os espaços em branco potenciais no lado esquerdo, se deve remover todos os espaços em branco potenciais no lado direito, etc. special_tokens (`bool`, *opcional*, padrão `False`) : Especifica se o token é especial. Isso altera principalmente o comportamento de normalização. Veja os detalhes de `tokenizers.AddedToken` na biblioteca HuggingFace tokenizers. **Retorna:** `int` Número de tokens adicionados ao vocabulário. #TODO remover isso daqui! PreTrainedTokenizerBase deve ser agnóstico de AddedToken. Adicione uma lista de novos tokens. Se os novos tokens não estiverem no vocabulário, eles são adicionados ao final. Portanto, os tokens adicionados e os tokens do vocabulário do algoritmo de tokenização não são tratados da mesma forma. Tokenizadores rápidos com um pré-tokenizador `Metaspace` usando `prepend_scheme="always"` (por exemplo, NLLB) adicionam `"▁"` ao texto que segue um token adicionado. Após `tokenizer.add_tokens(["abcd"])`, `"abcdgym"` é tokenizado como `["abcd", "▁gym"]` e decodificado para `"abcd gym"`. Se os tokens adicionados podem aparecer dentro de palavras, altere o pré-tokenizador para `prepend_scheme="first"`, para que apenas o início da entrada seja prefixado: ```python from tokenizers import pre_tokenizers pre_tokenizer = tokenizer.backend_tokenizer.pre_tokenizer tokenizer.backend_tokenizer.pre_tokenizer = pre_tokenizers.Metaspace( replacement=pre_tokenizer.replacement, prepend_scheme="first", split=pre_tokenizer.split ) ``` Exemplos: ```python # Let's see how to increase the vocabulary of Bert model and tokenizer tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased") model = BertModel.from_pretrained("google-bert/bert-base-uncased") num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"]) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) ``` #### apply_chat_template[[transformers.PreTrainedTokenizerBase.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | Callable] | None = None, documents: list[dict[str, str]] | None = None, chat_template: str | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, tokenize: bool = True, sanitize_control_tokens: bool = False, padding: bool | str | PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | TensorType | None = None, return_dict: bool = True, return_assistant_tokens_mask: bool = False, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L3021) **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 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 uso de ferramentas](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools) para mais informações. documents (`list[dict[str, str]]`, *opcional*) : Uma lista de dicionários representando documentos que ficarão acessíveis ao modelo caso ele esteja executando RAG (geração aumentada por recuperação). Se o template não suportar RAG, este argumento não terá efeito. Recomendamos que cada documento seja um dicionário contendo as chaves "title" e "text". chat_template (`str`, *opcional*) : Um modelo Jinja a ser usado para esta conversão. Geralmente, não é necessário passar nada para este argumento, pois o modelo do modelo será usado por padrão. add_generation_prompt (bool, *opcional*) : Se definido, um prompt com o(s) token(s) que indicam o início de uma mensagem do assistente será anexado à saída formatada. Isso é útil quando você deseja gerar uma resposta a partir do modelo. Observe que este argumento será passado para o modelo de chat, portanto, ele deve ser suportado no modelo para que este argumento tenha algum efeito. continue_final_message (bool or str, *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. Se uma string for passada, ela será usada como chave para o campo a ser continuado (por exemplo, "reasoning_content"). 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. sanitize_control_tokens (`bool`, padrão `False`) : Se definido, os tokens de controle que aparecem em mensagens, ferramentas ou documentos são codificados como texto comum, de modo que apenas os tokens de controle escritos pelo próprio chat template são codificados como tokens. Os tokens de controle são os tokens especiais do tokenizer, além dos tokens adicionados em `tokenizer.chat_control_tokens`. Se essa variável não estiver definida, os tokens de controle são inferidos a partir dos tokens adicionados que aparecem no texto do chat template e em literais de string. Apenas tokens de controle inteiros são sanitizados, portanto, se o template unir strings da entrada para formar tokens de controle (como `'<|' + message['role'] + '|>'`), essas strings devem ser validadas separadamente. As chaves de dicionários também não são sanitizadas. 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á tensors de um framework específico. Não tem efeito se tokenize for `False`. Valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. return_dict (`bool`, padrão `True`) : Se deve retornar um dicionário com saídas nomeadas. Não tem efeito se tokenize for `False`. tokenizer_kwargs (`dict[str : Any]`, *opcional*): Kwargs adicionais para passar ao tokenizer. return_assistant_tokens_mask (`bool`, padrão `False`) : Se deve retornar uma máscara dos tokens gerados pelo assistente. Para tokens gerados pelo assistente, a máscara conterá 1. Para tokens de usuário e sistema, a máscara conterá 0. Essa funcionalidade está disponível apenas para modelos de chat que a suportam por meio da palavra-chave `{% generation %}`. - ****kwargs** : Kwargs adicionais para passar ao renderizador do template. Serão acessíveis pelo chat template. **Retorna:** `Union[list[int], Dict]` Uma lista de ids de tokens representando o chat tokenizado até o momento, incluindo tokens de controle. Esta saída está pronta para ser passada ao modelo, seja diretamente ou por meio de métodos como `generate()`. Se `return_dict` estiver definido, será retornado um dicionário de saídas do tokenizer em vez disso. Converte uma lista de dicionários com as chaves `"role"` e `"content"` em uma lista de ids de tokens. Este método é destinado ao uso com modelos de chat e lerá o atributo chat_template do tokenizer para determinar o formato e os tokens de controle a serem usados na conversão. #### batch_decode[[transformers.PreTrainedTokenizerBase.batch_decode]] ```python batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | 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_utils_base.py#L2933) **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*) : Serão passados para o método de decodificação específico do modelo subjacente. **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`. #### clean_up_tokenization[[transformers.PreTrainedTokenizerBase.clean_up_tokenization]] ```python clean_up_tokenization(text: str) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2204) Limpa os espaços de tokenização em um texto dado. Este método é usado principalmente para suporte a código remoto. #### convert_ids_to_tokens[[transformers.PreTrainedTokenizerBase.convert_ids_to_tokens]] ```python convert_ids_to_tokens(ids: int | list[int], skip_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1499) **Parâmetros:** ids (`int` ou `list[int]`) : O id do token (ou ids dos tokens) a ser convertido em tokens. skip_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais devem ser removidos durante a decodificação. **Retorna:** `str` ou `list[str]` O(s) token(s) decodificado(s). Converte um único índice ou uma sequência de índices em um token ou uma sequência de tokens, usando o vocabulário e os tokens adicionados. #### convert_tokens_to_ids[[transformers.PreTrainedTokenizerBase.convert_tokens_to_ids]] ```python convert_tokens_to_ids(tokens: str | list[str]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1483) **Parâmetros:** tokens (`str` ou `list[str]`) : Um ou vários token(s) para converter em id(s) de token. **Retorna:** `int` ou `list[int]` O id do token ou a lista de ids de tokens. Converte uma string de tokens (ou uma sequência de tokens) em um único id inteiro (ou uma sequência de ids), usando o vocabulário. #### convert_tokens_to_string[[transformers.PreTrainedTokenizerBase.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens: list[str]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2872) **Parâmetros:** tokens (`list[str]`) : O token a ser concatenado em uma string. **Retorna:** `str` Os tokens concatenados. Converte uma sequência de tokens em uma única string. A maneira mais simples de fazer isso é `" ".join(tokens)`, mas muitas vezes queremos remover os artefatos da tokenização subpalavra ao mesmo tempo. #### decode[[transformers.PreTrainedTokenizerBase.decode]] ```python decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2885) **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. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de decodificação específico do modelo subjacente. **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, ou uma lista de sequências em uma lista de strings, usando o tokenizer e o vocabulário, com opções para remover tokens especiais e limpar os espaços de tokenização. Semelhante a executar `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`. #### encode[[transformers.PreTrainedTokenizerBase.encode]] ```python encode(text: TextInput | PreTokenizedInput | EncodedInput, text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, padding_side: str | None = None, return_tensors: str | TensorType | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2263) **Parâmetros:** text (`str`, `list[str]` ou `list[int]`) : A primeira sequência a ser codificada. Pode ser uma string, uma lista de strings (string tokenizada usando o método `tokenize`) ou uma lista de inteiros (ids de string tokenizada usando o método `convert_tokens_to_ids`). text_pair (`str`, `list[str]` ou `list[int]`, *opcional*) : Sequência secundária opcional a ser codificada. Pode ser uma string, uma lista de strings (string tokenizada usando o método `tokenize`) ou uma lista de inteiros (ids de strings tokenizadas usando o método `convert_tokens_to_ids`). 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 automaticamente tokens `bos` ou `eos`. 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 de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for 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 do 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. is_split_into_words (`bool`, *opcional*, padrão `False`) : Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como `True`, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokenizará. Isso é útil para NER ou classificação de tokens. 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. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy. - ****kwargs** : Passados para o método `.tokenize()`. **Retorna:** `list[int]`, `torch.Tensor` ou `np.ndarray` Os ids tokenizados do texto. Converte uma string em uma sequência de ids (inteiros), usando o tokenizer e o vocabulário. Igual a executar `self.convert_tokens_to_ids(self.tokenize(text))`. #### encode_message_with_chat_template[[transformers.PreTrainedTokenizerBase.encode_message_with_chat_template]] ```python encode_message_with_chat_template(message: dict[str, str], conversation_history: list[dict[str, str]] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L3260) **Parâmetros:** message (`dict`) : Um dicionário com as chaves "role" e "content", representando a mensagem a ser tokenizada. conversation_history (`list[dict]`, *opcional*) : Uma lista de dicts com as chaves "role" e "content", representando o histórico do chat até o momento. Se você estiver tokenizando as mensagens uma a uma, deve passar as mensagens anteriores da conversa aqui. - ****kwargs** : Kwargs adicionais para passar ao método `apply_chat_template`. **Retorna:** `list[int]` Uma lista de ids de tokens representando a mensagem tokenizada. Tokeniza uma única mensagem. Este método é um wrapper de conveniência em torno de `apply_chat_template` que permite tokenizar mensagens uma a uma. Isso é útil para coisas como streaming token a token. Não há garantia de que este método seja perfeito. Para alguns modelos, pode ser impossível tokenizar robustamente mensagens individuais. Por exemplo, se o chat template adiciona tokens após cada mensagem, mas também possui um prefixo que é adicionado a todo o chat, será impossível distinguir um chat-start-token de um message-start-token. Nesses casos, este método fará o possível para encontrar a tokenização correta, mas pode não ser perfeito. **Nota:** Este método não suporta `add_generation_prompt`. Se você quiser adicionar um prompt de geração, deve fazê-lo separadamente após tokenizar a conversa. #### from_pretrained[[transformers.PreTrainedTokenizerBase.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', trust_remote_code = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1515) **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 os arquivos de vocabulário necessários para o tokenizer, por exemplo, salvos usando o método [save_pretrained()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), e.g., `./my_model_directory/`. - (**Deprecado**, não se aplica a todas as classes derivadas) um caminho para um único arquivo de vocabulário salvo (se e somente se o tokenizer exigir um único arquivo de vocabulário, como Bert ou XLNet), e.g., `./my_model_directory/vocab.txt`. 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. proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação. 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. subfolder (`str`, *opcional*) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co (por exemplo, para facebook/rag-token-base), especifique-a aqui. inputs (argumentos posicionais adicionais, *opcionais*) : Serão passados para o método `__init__` do Tokenizer. trust_remote_code (`bool`, *opcional*, padrão `False`) : Se permite ou não o uso de modelos personalizados definidos no Hub em seus próprios arquivos de modelagem. Essa opção deve ser definida como `True` apenas para repositórios nos quais você confia e cujo código você leu, pois ela executará o código presente no Hub na sua máquina local. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método `__init__` do Tokenizer. Podem ser usados para definir tokens especiais como `bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`. Consulte os parâmetros em `__init__` para mais detalhes. Instancie um [PreTrainedTokenizerBase](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (ou uma classe derivada) a partir de um tokenizer predefinido. É necessário passar `token=True` quando você deseja usar um modelo privado. Exemplos: ```python # We can't instantiate directly the base class *PreTrainedTokenizerBase* so let's show our examples on a derived class: BertTokenizer # Download vocabulary from huggingface.co and cache. tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased") # Download vocabulary from huggingface.co (user-uploaded) and cache. tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased") # If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*) tokenizer = BertTokenizer.from_pretrained("./test/saved_model/") # If the tokenizer uses a single vocabulary file, you can point directly to this file tokenizer = BertTokenizer.from_pretrained("./test/saved_model/my_vocab.txt") # You can link tokens to special vocabulary when instantiating tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased", unk_token="") # You should be sure '' is in the vocabulary when doing that. # Otherwise use tokenizer.add_special_tokens({'unk_token': ''}) instead) assert tokenizer.unk_token == "" ``` #### get_chat_template[[transformers.PreTrainedTokenizerBase.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_utils_base.py#L3320) **Parâmetros:** chat_template (`str`, *opcional*) : Um modelo Jinja ou o nome de um modelo a ser usado para esta conversão. Geralmente, não é necessário passar nada para este argumento, pois o modelo do modelo será usado por padrão. tools (`list[Dict]`, *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](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) para mais informações. **Retorna:** `str` A string do modelo de chat. Recupere a string do modelo de chat usada para a tokenização de mensagens de chat. Este modelo é usado internamente pelo método `apply_chat_template` e também pode ser usado externamente para recuperar o modelo de chat do modelo, permitindo um melhor acompanhamento da geração. #### get_response_parser[[transformers.PreTrainedTokenizerBase.get_response_parser]] ```python get_response_parser(response_template: dict | None = None, prefix: str | list[int] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L3517) Retorna um `ResponseParser` com estado para analisar incrementalmente uma resposta transmitida em streaming. Usa o atributo `response_template` do tokenizer, a menos que seja sobrescrito. `prefix` (uma string, lista de ids de tokens ou tensor 1D) é obrigatório: o stream é inicializado no estado implícito pelo contexto do prompt de chat (truncado à direita após o `start_anchor` da especificação), de modo que os blocos gerados enviados via `stream.feed()` são classificados corretamente, mesmo quando o template de chat emitiu conteúdo de turno do assistente (por exemplo, `\n`) a partir do qual o modelo continua. Omiti-lo gera uma exceção; se o stream realmente começa de um turno limpo do assistente, passe `prefix=""` para desativar. `tools` (`list[Union[Dict, Callable]]`, *opcional*): ferramentas disponíveis para o modelo, no mesmo formato aceito por `apply_chat_template`. Quando definido, os argumentos de chamada de ferramenta são convertidos usando o esquema JSON da ferramenta chamada à medida que cada região é fechada, de modo que os eventos de streaming `region_close` carregam argumentos tipados. #### get_special_tokens_mask[[transformers.PreTrainedTokenizerBase.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1338) **Parâmetros:** token_ids_0 : Lista de IDs da sequência (possivelmente já formatada). token_ids_1 : Não utilizado quando `already_has_special_tokens=True`. Deve ser None nesse caso. already_has_special_tokens : Indica se a sequência já está formatada com tokens especiais. **Retorna:** Uma lista de inteiros no intervalo [0, 1] 1 para um token especial, 0 para um token de sequência. Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados. Para tokenizadores rápidos, os data collators chamam isso com `already_has_special_tokens=True` para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em `all_special_ids`. #### get_vocab[[transformers.PreTrainedTokenizerBase.get_vocab]] ```python get_vocab() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1471) **Retorna:** `dict[str, int]` O vocabulário. Retorna o vocabulário como um dicionário de token para índice. `tokenizer.get_vocab()[token]` é equivalente a `tokenizer.convert_tokens_to_ids(token)` quando `token` está no vocabulário. #### pad[[transformers.PreTrainedTokenizerBase.pad]] ```python pad(encoded_inputs: BatchEncoding | list[BatchEncoding] | dict[str, EncodedInput] | dict[str, list[EncodedInput]] | list[dict[str, EncodedInput]], padding: bool | str | PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | TensorType | None = None, verbose: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2600) **Parâmetros:** encoded_inputs ([BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding), lista de [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding), `dict[str, list[int]]`, `dict[str, list[list[int]]` ou `list[dict[str, list[int]]]`) : Entradas tokenizadas. Pode representar uma única entrada ([BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) ou `dict[str, list[int]]`) ou um lote de entradas tokenizadas (lista de [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding), *dict[str, list[list[int]]]* ou *list[dict[str, list[int]]]*), permitindo o uso deste método tanto durante o pré-processamento quanto em uma função de colagem de um Dataloader do PyTorch. Em vez de `list[int]`, você pode ter tensores (arrays numpy ou tensores do PyTorch); consulte a observação acima sobre o tipo de retorno. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `True`) : 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'` (padrão): 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'`: Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). max_length (`int`, *opcional*) : Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima). pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. 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_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_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. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy. verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos. Preencha um único entrada codificada ou um lote de entradas codificadas até um comprimento predefinido ou até o comprimento máximo da sequência no lote. O lado do padding (esquerda/direita) e os ids de tokens de padding são definidos no nível do tokenizer (com `self.padding_side`, `self.pad_token_id` e `self.pad_token_type_id`). Observe que, com um tokenizer rápido, usar o método `__call__` é mais rápido do que usar um método para codificar o texto seguido de uma chamada ao método `pad` para obter uma codificação com padding. Se o `encoded_inputs` passado for um dicionário de arrays numpy ou tensores PyTorch, o resultado usará o mesmo tipo, a menos que você forneça um tipo de tensor diferente com `return_tensors`. No caso de tensores PyTorch, você perderá o dispositivo específico dos seus tensores. #### parse_response[[transformers.PreTrainedTokenizerBase.parse_response]] ```python parse_response(response: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor, schema: dict | None = None, prefix: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L3432) **Parâmetros:** response (`str`, ids de tokens, tensor 1D/2D ou uma lista desses) : A saída gerada pelo modelo. Pode ser texto decodificado ou ids de tokens, como uma única sequência (`str` / `list[int]` / array 1D / tensor 1D) ou um lote (`list[str]` / `list[list[int]]` / array 2D / tensor 2D). Observe que isso deve conter apenas a saída do modelo, sem qualquer texto de prompt anterior (esse vai em `prefix`). schema (`dict`, *opcional*) : Um modelo de resposta que indica o formato de saída esperado e como o parsing deve ser realizado. Se não for fornecido, o atributo `response_template` do tokenizer será utilizado. prefix (`str`, ids de tokens, tensor 1D/2D ou uma lista desses) : O prompt que veio antes da geração. Isso é necessário porque muitos modelos de chat pré-escrevem parte da mensagem, então precisamos ver o prompt para fazer a análise corretamente. Para um `response` em lote, passe um único prefixo (disseminado para cada item) ou um prefixo por item. tools (`list[Union[Dict, Callable]]`, *opcional*) : Ferramentas disponíveis para o modelo, no mesmo formato aceito por `apply_chat_template`. Quando fornecidas, os argumentos de chamada de ferramenta são convertidos usando o esquema JSON da ferramenta chamada: `"7"` se torna `7` para um parâmetro inteiro, mas permanece `"7"` para um parâmetro de string. **Retorna:** Um dicionário `dict` de mensagem analisada para uma única sequência, ou uma `list` de tais dicionários para um lote. Converte uma string de saída criada pela geração de texto de um modelo em um dicionário de mensagem analisado. Este método é destinado ao uso com modelos de chat e lerá o atributo `response_template` do tokenizer para controlar a análise, a menos que um argumento `schema` seja passado diretamente. Aceita uma única sequência ou um lote. Uma única sequência (uma string ou uma sequência 1D de ids de tokens) retorna um único dicionário de mensagem analisado `dict`; um lote (uma lista de strings, uma lista de sequências de ids de tokens ou um tensor/matriz 2D) retorna uma `list` de dicionários de mensagens analisados, um para cada item. #### push_to_hub[[transformers.PreTrainedTokenizerBase.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822) **Parâmetros:** repo_id (`str`) : O nome do repositório para o qual você deseja enviar seu tokenizer. Deve conter o nome da sua organização ao enviar para uma organização específica. commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O valor padrão será `"Upload tokenizer"`. commit_description (`str`, *opcional*) : A descrição do commit que será criado private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`bool` ou `str`, *opcional*) : O token a ser usado como autorização bearer HTTP para arquivos remotos. Se `True` (padrão), usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`). revision (`str`, *opcional*) : Branch para a qual os arquivos enviados serão enviados. create_pr (`bool`, *opcional*, padrão `False`) : Se deve ou não criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : Aplicável apenas a modelos. O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve conter dígitos seguidos de uma unidade (como `"5MB"`). tags (`list[str]`, *opcional*) : Lista de tags para enviar no Hub. Envie os arquivos do tokenizer para o 🤗 Model Hub. Exemplos: ```python from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased") # Push the tokenizer to your namespace with the name "my-finetuned-bert". tokenizer.push_to_hub("my-finetuned-bert") # Push the tokenizer to an organization with the name "my-finetuned-bert". tokenizer.push_to_hub("huggingface/my-finetuned-bert") ``` #### register_for_auto_class[[transformers.PreTrainedTokenizerBase.register_for_auto_class]] ```python register_for_auto_class(auto_class = 'AutoTokenizer') ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L3001) **Parâmetros:** auto_class (`str` ou `type`, *opcional*, padrão `"AutoTokenizer"`) : A classe auto com a qual este novo tokenizer deve ser registrado. Registre esta classe com uma classe auto específica. Isso deve ser usado apenas para tokenizadores personalizados, pois os da biblioteca já estão mapeados com `AutoTokenizer`. #### save_chat_templates[[transformers.PreTrainedTokenizerBase.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_utils_base.py#L3374) Escreve os modelos de chat no diretório de salvamento se estivermos usando o novo formato e os remove da configuração do tokenizer, caso estejam presentes. Se estivermos usando o formato legado, não escreve nenhum arquivo e, em vez disso, grava os modelos na configuração do tokenizer no formato correto. #### save_pretrained[[transformers.PreTrainedTokenizerBase.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, legacy_format: bool | None = None, filename_prefix: str | None = None, push_to_hub: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2006) **Parâmetros:** save_directory (`str` ou `os.PathLike`) : O caminho para um diretório onde o tokenizer será salvo. legacy_format (`bool`, *opcional*) : Aplicável apenas para um tokenizer rápido. Se não definido (padrão), salvará o tokenizer no formato JSON unificado, bem como no formato legado, se este existir, ou seja, com o vocabulário específico do tokenizer e um arquivo separado de added_tokens. Se `False`, salvará o tokenizer apenas no formato JSON unificado. Este formato é incompatível com tokenizers "lentos" (não baseados na biblioteca *tokenizers*), portanto, o tokenizer não poderá ser carregado no tokenizer "lento" correspondente. Se `True`, salvará o tokenizer no formato legado. Se o tokenizer "lento" não existir, um value error será lançado. filename_prefix (`str`, *opcional*) : Um prefixo a ser adicionado aos nomes dos arquivos salvos pelo tokenizer. push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace). kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). **Retorna:** uma tupla de `str` Os arquivos salvos. Salve o estado completo do tokenizer. Esse método garante que o tokenizer completo possa, em seguida, ser recarregado usando o método de classe `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`. Warning,None Isso não salvará as modificações que você possa ter aplicado ao tokenizer após a instanciação (por exemplo, modificar `tokenizer.do_lower_case` após a criação). #### save_vocabulary[[transformers.PreTrainedTokenizerBase.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2225) **Parâmetros:** save_directory (`str`) : O diretório em que salvar o vocabulário. filename_prefix (`str`, *opcional*) : Um prefixo opcional para adicionar ao nome dos arquivos salvos. **Retorna:** `tuple(str)` Caminhos para os arquivos salvos. Salve apenas o vocabulário do tokenizer (vocabulário + tokens adicionados). Esse método não salvará a configuração e os mapeamentos de tokens especiais do tokenizer. Use `_save_pretrained()` para salvar todo o estado do tokenizer. #### tokenize[[transformers.PreTrainedTokenizerBase.tokenize]] ```python tokenize(text: str, pair: str | None = None, add_special_tokens: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2243) **Parâmetros:** text (`str`) : A sequência a ser codificada. pair (`str`, *opcional*) : Uma segunda sequência a ser codificada junto com a primeira. add_special_tokens (`bool`, *opcional*, padrão `False`) : Indica se os tokens especiais associados ao modelo correspondente devem ser adicionados. kwargs (argumentos de palavra-chave adicionais, *opcional*) : Serão passados para o método de codificação específico do modelo subjacente. Veja os detalhes em [__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) **Retorna:** `list[str]` A lista de tokens. Converte uma string em uma sequência de tokens, substituindo tokens desconhecidos pelo `unk_token`. ## Enums e namedtuples[[transformers.tokenization_utils_base.TruncationStrategy]] #### transformers.tokenization_utils_base.TruncationStrategy[[transformers.tokenization_utils_base.TruncationStrategy]] ```python transformers.tokenization_utils_base.TruncationStrategy(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L160) Valores possíveis para o argumento `truncation` em [PreTrainedTokenizerBase.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). Útil para a conclusão de comandos por tabulação em uma IDE. #### transformers.CharSpan[[transformers.CharSpan]] ```python transformers.CharSpan(start: ForwardRef('int'), end: ForwardRef('int')) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L172) **Parâmetros:** start (`int`) : Índice do primeiro caractere na string original. end (`int`) : Índice do caractere que segue o último caractere na string original. Intervalo de caracteres na string original. #### transformers.TokenSpan[[transformers.TokenSpan]] ```python transformers.TokenSpan(start: ForwardRef('int'), end: ForwardRef('int')) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L185) **Parâmetros:** start (`int`) : Índice do primeiro token no intervalo. end (`int`) : Índice do token que segue o último token do intervalo. Intervalo de tokens em uma string codificada (lista de tokens).